Buscando caché en memoria Java simple

Question

Estoy buscando un caché simple en memoria Java que tenga buena concurrencia (por lo que LinkedHashMap no es lo suficientemente bueno), y que se puede serializar en el disco periódicamente.

Una característica que necesito, pero que ha resultado difícil de encontrar, es una forma de "mirar" un objeto. Con esto me refiero a recuperar un objeto de la memoria caché sin hacer que la memoria caché se aferre al objeto más de lo que lo hubiera hecho de otra manera.

Actualización: Un requisito adicional que omití mencionar es que necesito poder modificar los objetos en caché (que contienen matrices flotantes) en el lugar.

¿Alguien puede proporcionar alguna recomendación?

Answer 1

Dado que esta pregunta fue hecha en un principio, ahora Google's Guava library incluye un potente y flexible caché. Yo recomendaría usar esto.

Answer 2

¿Qué tal esto: https://commons.apache.org/proper/commons-jcs/ (actualizado a la nueva dirección, como JCS se encuentra ahora en Apache Commons)

Answer 3

Ehcache es una muy buena solución para esto y tiene una manera de mirar (getQuiet() es el método) de tal manera que no actualiza la marca de tiempo inactiva. Internamente, Ehcache se implementa con un conjunto de mapas, algo así como ConcurrentHashMap, por lo que tiene tipos similares de ventajas de concurrencia.

Answer 4

Probar Ehcache? Le permite conectar sus propios algoritmos de caducidad de caché para que pueda controlar su funcionalidad de peek.

Puede serializar en el disco, base de datos, a través de un cluster, etc ...

Answer 5

Si usted está necesitando algo simple, sería esta forma la factura?

Map<K, V> myCache = Collections.synchronizedMap(new WeakHashMap<K, V>()); 

No lo puedo guardar en el disco, pero dijo que quería sencilla ...

Enlaces:

• Collections.synchronizedMap
• WeakHashMap

(como Adam comentó, sincronizar un mapa tiene un impacto en el rendimiento. No decir que la idea no tiene pelos en mi t, pero bastaría como una solución rápida y sucia)

Answer 6

Prueba esto:.

import java.util.*; 

public class SimpleCacheManager { 

    private static SimpleCacheManager instance; 
    private static Object monitor = new Object(); 
    private Map<String, Object> cache = Collections.synchronizedMap(new HashMap<String, Object>()); 

    private SimpleCacheManager() { 
    } 

    public void put(String cacheKey, Object value) { 
     cache.put(cacheKey, value); 
    } 

    public Object get(String cacheKey) { 
     return cache.get(cacheKey); 
    } 

    public void clear(String cacheKey) { 
     cache.put(cacheKey, null); 
    } 

    public void clear() { 
     cache.clear(); 
    } 

    public static SimpleCacheManager getInstance() { 
     if (instance == null) { 
      synchronized (monitor) { 
       if (instance == null) { 
        instance = new SimpleCacheManager(); 
       } 
      } 
     } 
     return instance; 
    } 

} 

Answer 7

Puede usar fácilmente imcache. Un código de muestra está debajo.

void example(){ 
    Cache<Integer,Integer> cache = CacheBuilder.heapCache(). 
    cacheLoader(new CacheLoader<Integer, Integer>() { 
     public Integer load(Integer key) { 
      return null; 
     } 
    }).capacity(10000).build(); 
} 

Answer 8

Otra opción para una memoria caché java en memoria es cache2k. El rendimiento en memoria es superior a EHCache y Google guava, consulte el cache2k benchmarks page.

El patrón de uso es similar a otros cachés.Aquí está un ejemplo:

Cache<String,String> cache = new Cache2kBuilder<String, String>() {} 
    .expireAfterWrite(5, TimeUnit.MINUTES) // expire/refresh after 5 minutes 
    .resilienceDuration(30, TimeUnit.SECONDS) // cope with at most 30 seconds 
              // outage before propagating 
              // exceptions 
    .refreshAhead(true)      // keep fresh when expiring 
    .loader(new CacheLoader<String, String>() { 
    @Override 
    public String load(final String key) throws Exception { 
     return ....; 
    } 
    }) 
    .build(); 
String val = cache.peek("something"); 
cache.put("something", "hello"); 
val = cache.get("something"); 

Si tiene Google de guayaba como la dependencia a continuación, probar caché guayaba, puede ser una buena alternativa.

Answer 9

Probar @Cacheable de jcabi-aspects. Con una sola anotación que hacen que todo el resultado del método puede almacenar en caché en la memoria:

public class Resource { 
    @Cacheable(lifetime = 5, unit = TimeUnit.SECONDS) 
    public String load(URL url) { 
    return url.openConnection().getContent(); 
    } 
} 

Además, lea este artículo: http://www.yegor256.com/2014/08/03/cacheable-java-annotation.html