Implementación de un caché usando un java ConcurrentHashMap

Question

Me gustaría implementar un simple caché de objetos pesados ​​en una aplicación web java. Pero no puedo entender cómo hacerlo correctamente.

¿Me falta algo o los métodos ConcurrentHashMap (putIfAbsent, ...) no son suficientes y se necesita sincronización adicional?

¿Existe una mejor API simple (en almacenamiento de memoria, sin configuración externa) para hacer esto?

P.

Answer 1

si es seguro tener temporalmente más de una instancia de lo que estamos tratando de caché, se puede hacer una caché "sin bloqueo" de esta manera:

public Heavy instance(Object key) { 
    Heavy info = infoMap.get(key); 
    if (info == null) { 
    // It's OK to construct a Heavy that ends up not being used 
    info = new Heavy(key); 
    Heavy putByOtherThreadJustNow = infoMap.putIfAbsent(key, info); 
    if (putByOtherThreadJustNow != null) { 
     // Some other thread "won" 
     info = putByOtherThreadJustNow; 
    } 
    else { 
     // This thread was the winner 
    } 
    } 
    return info; 
} 

múltiples hilos puede "competir" para crear y agregar un elemento para la llave, pero solo uno debe "ganar".

Answer 2

ConcurrentHashMap debería ser suficiente para sus necesidades putIfAbsent es hilo de seguridad.

No sé cuánto más simple se puede obtener

ConcurrentMap myCache = new ConcurrentHashMap(); 

Paul

Answer 3

En lugar de poner los "objetos pesados" en la memoria caché, puede utilizar objetos de fábrica de la luz para crear una caché activa.

public abstract class LazyFactory implements Serializable { 

    private Object _heavyObject; 

    public getObject() { 
    if (_heavyObject != null) return _heavyObject; 
    synchronized { 
     if (_heavyObject == null) _heavyObject = create(); 
    } 
    return _heavyObject; 
    } 

    protected synchronized abstract Object create(); 
} 

// here's some sample code 

// create the factory, ignore negligible overhead for object creation 
LazyFactory factory = new LazyFactory() { 
    protected Object create() { 
    // do heavy init here 
    return new DbConnection(); 
    }; 
}; 
LazyFactory prev = map.pufIfAbsent("db", factory); 
// use previous factory if available 
return prev != null ? prev.getObject() : factory.getObject; 

Answer 4

Además de la respuesta de Ken, si la creación de un objeto pesado que luego se desecha NO es aceptable (desea garantizar que solo se crea un objeto para cada tecla, por algún motivo), puede hacerlo ... .. en realidad, no. No lo hagas tú mismo. Utilice la google-collections (ahora guava) MapMaker class:

Map<KeyType, HeavyData> cache = new MapMaker<KeyType, HeavyData>() 
    .makeComputingMap(new Function<KeyType, HeavyData>() { 
     public HeavyData apply(KeyType key) { 
      return new HeavyData(key); // Guaranteed to be called ONCE for each key 
     } 
    }); 

A continuación, un simple cache.get(key) solo funciona y completamente se quita de tener que preocuparse acerca de los aspectos difíciles de concurrencia y syncrhonization.

Tenga en cuenta que si quieres añadir algunas características más elegantes, como caducidad, es sólo

Map<....> cache = new MapMaker<....>() 
    .expiration(30, TimeUnit.MINUTES) 
    .makeComputingMap(.....) 

y también se puede utilizar fácilmente los valores blandos o débiles, ya sea para las llaves o los datos si es necesario (consulte el Javadoc para obtener más detalles)

Answer 5

Me doy cuenta de que esta es una publicación anterior, pero en Java 8 esto se puede hacer sin crear un objeto pesado potencialmente no utilizado con un ConcurrentHashMap.

public class ConcurrentCache4<K,V> { 
    public static class HeavyObject 
    { 
    } 

    private ConcurrentHashMap<String, HeavyObject> cache = new ConcurrentHashMap<>(); 

    public HeavyObject get(String key) 
    { 
     HeavyObject heavyObject = cache.get(key); 
     if (heavyObject != null) { 
      return heavyObject; 
     } 

     return cache.computeIfAbsent(key, k -> new HeavyObject()); 
    } 
}