Procurando por cache simples em memória Java [fechado]

Estou procurando um cache em memória Java simples que tenha boa simultaneidade (portanto, LinkedHashMap não é bom o suficiente) e que pode ser serializado em disco periodicamente.

Um recurso de que preciso, mas que se mostrou difícil de encontrar, é uma maneira de "espiar" um objeto. Com isso, quero dizer recuperar um objeto do cache sem fazer com que o cache segure o objeto por mais tempo do que o faria de outra forma.

Atualização: um requisito adicional que esqueci de mencionar é que preciso ser capaz de modificar os objetos em cache (eles contêm matrizes flutuantes) no local.

Alguém pode fornecer alguma recomendação?

Como essa pergunta foi feita originalmente, a biblioteca Guava do Google agora inclui um cache poderoso e flexível. Eu recomendaria usar isso.

Ehcache é uma solução muito boa para isso e tem uma maneira de espiar ( getQuiet () é o método) de forma que não atualize o timestamp ocioso. Internamente, o Ehcache é implementado com um conjunto de mapas, como o ConcurrentHashMap, portanto, tem tipos semelhantes de benefícios de simultaneidade.

Se você está precisando de algo simples, isso seria adequado?

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

Não vai salvar no disco, mas você disse que queria simples ...

Links:

• Collections.synchronizedMap
• WeakHashMap

(Como Adam comentou, sincronizar um mapa tem um impacto no desempenho. Não estou dizendo que a ideia não tem cabelos, mas seria suficiente como uma solução rápida e suja.)

Outra opção para um cache java em memória é cache2k . O desempenho na memória é superior ao EHCache e google guava, consulte a página de benchmarks cache2k .

O padrão de uso é semelhante a outros caches. Aqui está um exemplo:

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");

Se você tiver o google goiaba como dependência, experimentar o cache de goiaba pode ser uma boa alternativa.

Você pode usar o imcache facilmente . Um exemplo de código está abaixo.

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

Experimente isto:

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

}

Experimente aspectos@Cacheable do jcabi . Com uma única anotação, você torna todo o resultado do método armazenável em cache na memória:

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

Além disso, leia este artigo: http://www.yegor256.com/2014/08/03/cacheable-java-annotation.html

Que tal: https://commons.apache.org/proper/commons-jcs/ (atualizado para o novo endereço, pois JCS agora está no Apache Commons)

Experimente Ehcache ? Ele permite que você conecte seus próprios algoritmos de expiração de cache para que você possa controlar sua funcionalidade de visualização.

Você pode serializar em disco, banco de dados, em um cluster, etc ...