Cómo adquirir un candado con una llave

Question

¿Cuál es la mejor manera de evitar la actualización simultánea de un registro en un conjunto clave-valor sin bloquear todo el conjunto? Semánticamente, estoy buscando algún tipo de bloqueo por una llave (a ser posible, la aplicación Java, pero no necesariamente):

interface LockByKey { 
    void lock(String key); // acquire an exclusive lock for a key 
    void unlock(String key); // release lock for a key 
} 

Este bloqueo está destinado para sincronizar el acceso a una tienda a distancia, por lo que algunos colección de Java sincronizado no es una opinión.

Answer 1

Guava tiene algo así como esto lanzado en 13.0; puedes sacarlo de HEAD si quieres.

Striped<Lock> asigna más o menos un número específico de bloqueos, y luego asigna cadenas a bloqueos basados ​​en su código hash. La API se ve más o menos como

Striped<Lock> locks = Striped.lock(stripes); 
Lock l = locks.get(string); 
l.lock(); 
try { 
    // do stuff 
} finally { 
    l.unlock(); 
} 

Más o menos, el número controlable de rayas le permite operar concurrencia contra el uso de memoria, debido a la asignación de un bloqueo total para cada clave de cadena puede ser caro; esencialmente, solo obtienes contienda de bloqueo cuando obtienes colisiones hash, que son (previsiblemente) raras.

(Revelación:. Contribuyo a guayaba)

Answer 2

Mantenga un mutex/bloqueo por cubo. Esto asegurará que solo las colisiones esperen en ese mutex.

Answer 3

Si el "registro" que menciona es un objeto mutable y "actualizar" significa que el estado interno del objeto se modifica sin alterar la estructura del contenedor, entonces puede lograr lo que desee simplemente bloqueando el objeto de registro.

Sin embargo, si "actualizar" significa eliminar el objeto de registro del contenedor y reemplazarlo, entonces debe bloquear todo el contenedor para evitar que otros subprocesos lo vean en un estado incoherente.

En cualquier caso, debe consultar las clases en el paquete java.util.concurrent.

Answer 4

Esta es la forma; lo hice. Y sí, estoy de acuerdo en que si dos cadenas diferentes comparten el mismo código hash terminarán adquiriendo el mismo bloqueo.

class LockByKey { 
    ObjectForString objHolder = new ObjectForString(100); 
    public void lockThenWorkForKey (String key) { 
     synchronized(objHolder.valueOf(key)){ 
      //DoSomeWork 
     } 
    } 
} 

public final class ObjectForString { 

    private final Object[] cache; 
    private final int cacheSize; 
    final int mask; 

    public ObjectForString(int size) { 
     // Find power-of-two sizes best matching arguments 
     int ssize = 1; 
     while (ssize < size) { 
      ssize <<= 1; 
     } 

     mask = ssize - 1; 
     cache = new Object[ssize]; 
     cacheSize = ssize; 
     //build the Cache 
     for (int i = 0; i < cacheSize; i++) { 
      this.cache[i] = new Object(); 
     } 
    } 

    public Object valueOf(String key) { 
     int index = key.hashCode(); 
     return cache[index & mask]; 
    } 
}