Caché LRU fácil de usar en java

Question

Sé que es fácil de implementar, pero quiero reutilizar algo que ya existe.

Problema que quiero resolver es que cargo la configuración (desde XML, así que quiero almacenarlos en caché) para diferentes páginas, roles, ... por lo que la combinación de entradas puede crecer bastante (pero en 99% no) . Para manejar este 1%, quiero tener un número máximo de elementos en la memoria caché ...

Sé que he encontrado org.apache.commons.maplections.map.LRUMap en apache commons y se ve bien, pero quiero verifique también algo más. ¿Alguna recomendación?

Answer 1

Puede utilizar un LinkedHashMap (Java 1.4+):

// Create cache 
final int MAX_ENTRIES = 100; 
Map cache = new LinkedHashMap(MAX_ENTRIES+1, .75F, true) { 
    // This method is called just after a new entry has been added 
    public boolean removeEldestEntry(Map.Entry eldest) { 
     return size() > MAX_ENTRIES; 
    } 
}; 

// Add to cache 
Object key = "key"; 
cache.put(key, object); 

// Get object 
Object o = cache.get(key); 
if (o == null && !cache.containsKey(key)) { 
    // Object not in cache. If null is not a possible value in the cache, 
    // the call to cache.contains(key) is not needed 
} 

// If the cache is to be used by multiple threads, 
// the cache must be wrapped with code to synchronize the methods 
cache = (Map)Collections.synchronizedMap(cache); 

Answer 2

Ésta es una vieja pregunta, pero para la posteridad me quería a la lista ConcurrentLinkedHashMap, que es hilo de seguridad, a diferencia de LRUMap. El uso es muy fácil:

ConcurrentMap<K, V> cache = new ConcurrentLinkedHashMap.Builder<K, V>() 
    .maximumWeightedCapacity(1000) 
    .build(); 

Y la documentación tiene un buen examples, como la forma de hacer que en lugar de número-de-elementos en función del tamaño de la caché de base LRU.

Answer 3

También tuve el mismo problema y no encontré ninguna buena biblioteca ... así que creé la mía.

simplelrucache proporciona un almacenamiento en memoria caché de LRU no distribuido, muy simple y no distribuido con soporte TTL. Proporciona dos implementaciones

• concurrentes basado en ConcurrentLinkedHashMap
• sincronizada basan en LinkedHashMap

Se puede encontrar here.

Answer 4

Here es un caché LRU muy simple y fácil de usar en Java. Aunque es corto y simple, es calidad de producción. Se explica el código (consulte el archivo README.md) y tiene algunas pruebas de unidad.

Answer 5

Aquí está mi implementación que me permite mantener una cantidad óptima de elementos en la memoria.

El punto es que no necesito hacer un seguimiento de qué objetos están siendo utilizados actualmente ya que estoy usando una combinación de un LinkedHashMap para los objetos MRU y un WeakHashMap para los objetos LRU. Por lo tanto, la capacidad de caché no es menor que el tamaño de MRU y todo lo que el GC me permite conservar. Cuando los objetos se caen de la MRU van a la LRU mientras el GC los tenga.

public class Cache<K,V> { 
final Map<K,V> MRUdata; 
final Map<K,V> LRUdata; 

public Cache(final int capacity) 
{ 
    LRUdata = new WeakHashMap<K, V>(); 

    MRUdata = new LinkedHashMap<K, V>(capacity+1, 1.0f, true) { 
     protected boolean removeEldestEntry(Map.Entry<K,V> entry) 
     { 
      if (this.size() > capacity) { 
       LRUdata.put(entry.getKey(), entry.getValue()); 
       return true; 
      } 
      return false; 
     }; 
    }; 
} 

public synchronized V tryGet(K key) 
{ 
    V value = MRUdata.get(key); 
    if (value!=null) 
     return value; 
    value = LRUdata.get(key); 
    if (value!=null) { 
     LRUdata.remove(key); 
     MRUdata.put(key, value); 
    } 
    return value; 
} 

public synchronized void set(K key, V value) 
{ 
    LRUdata.remove(key); 
    MRUdata.put(key, value); 
} 
}