Pregunta Buscando caché en memoria Java simple [cerrado]


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.

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

¿Alguien puede proporcionar alguna recomendación?


74
2018-02-22 20:11


origen


Respuestas:


Dado que esta pregunta fue originalmente hecha, La biblioteca de guayaba de Google ahora incluye una memoria caché potente y flexible. Yo recomendaría usar esto.


48
2018-03-25 16:02



Ehcache es una buena solución para esto y tiene una forma de mirargetQuiet () 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.


34
2018-02-22 20:17



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:

(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).


16
2018-02-23 01:02



Otra opción para una memoria caché java en memoria es cache2k.  El rendimiento en memoria es superior a EHCache y google guava, vea el página de puntos de referencia 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.


12
2018-02-25 16:49



Puedes usarlo 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(); 
}

9
2018-01-16 20:38



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

}

8
2018-03-20 13:33



Tratar @Cacheable de jcabi-aspectos. 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


6
2017-09-12 15:17



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


3
2018-02-22 20:16



Tratar 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.


0
2018-02-22 20:17