Buscando caché en memoria de Java simple [cerrado]

Estoy buscando un caché en memoria de Java simple que tenga buena concurrencia (por lo que LinkedHashMap no es lo suficientemente bueno) y que se pueda 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 caché sin hacer que la caché se aferre al objeto más tiempo del que tendría de otra manera.

Actualización: un requisito adicional que olvidé mencionar es que necesito poder modificar los objetos en caché (contienen matrices flotantes) en su lugar.

¿Alguien puede dar alguna recomendación?

Dado que esta pregunta se hizo originalmente, la biblioteca Guava de Google ahora incluye un caché potente y flexible. Recomendaría usar esto.

Ehcache es una solución bastante buena para esto y tiene una forma de echar un vistazo ( getQuiet () es el método) de 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 beneficios de concurrencia.

Si necesita algo simple, ¿esto se ajusta a la factura?

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

No se guardará en el disco, pero dijiste que querías simple ...

Enlaces:

• Collections.synchronizedMap
• WeakHashMap

(Como comentó Adam, sincronizar un mapa tiene un impacto en el rendimiento. No digo que la idea no tenga pelos en ella, pero sería suficiente como una solución rápida y sucia).

Otra opción para un caché de Java en memoria es cache2k . El rendimiento en memoria es superior al de EHCache y google guava, consulte la página de pruebas de rendimiento de cache2k .

El patrón de uso es similar a otros cachés. Aquí hay 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 guava como dependencia, probar el caché de guayaba puede ser una buena alternativa.

Puedes usar imcache fácilmente . A continuación se muestra un código de muestra.

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

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;
    }

}

Prueba @Cacheabledesde jcabi-aspectos . Con una sola anotación, hace que todo el resultado del método se pueda 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

¿Qué tal esto? Https://commons.apache.org/proper/commons-jcs/ (actualizado a la nueva dirección, ya que JCS ahora está en Apache Commons)

¿Prueba Ehcache ? Le permite conectar sus propios algoritmos de caducidad de almacenamiento en caché para que pueda controlar su funcionalidad de inspección.

Puede serializar en disco, base de datos, en un clúster, etc.