manejo - Buscando caché en memoria Java simple

manejo de cache en java

Question

Estoy buscando un simple caché en memoria de 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 se realizó originalmente, la biblioteca de Guava de Google ahora incluye una memoria caché potente y flexible. Yo recomendaría usar esto.

Answer 2

Otra opción para una memoria caché java en memoria es cache2k . El rendimiento en memoria es superior a 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 tienes google guava como dependencia entonces probar guava cache, puede ser una buena alternativa.

Answer 3

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 4

Pruebe @Cacheable desde jcabi-aspects . Con una sola anotación, puede hacer que todo el método resulte almacenable 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

Answer 5

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

Puede serializar en disco, base de datos, a través de un clúster, etc.

Answer 6

Puedes usar imcache fácilmente. 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 7

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

Answer 8

Si necesita algo simple, ¿esto encajaría?

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

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

Campo de golf:

• Collections.synchronizedMap
• WeakHashMap

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

Answer 9

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