it-swarm-pt.tech

Procurando por cache simples Java in-memory

Estou à procura de um cache de memória simples Java que tenha boa simultaneidade (assim LinkedHashMap não é bom o suficiente), e que pode ser serializado para o disco periodicamente.

Um recurso 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 mantenha o objeto por mais tempo do que teria.

pdate: Um requisito adicional que deixei de mencionar é que eu preciso modificar os objetos em cache (eles contêm matrizes flutuantes) no local.

Alguém pode fornecer alguma recomendação?

88
sanity

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

53
sanity

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

36
Alex Miller

Se você está precisando de algo simples, isso se encaixaria na conta?

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

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

Links:

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

19
Evan

Outra opção para um cache in-memory Java é cache2k . O desempenho na memória é superior ao EHCache e google goava, veja o cache2k benchmarks page .

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ê tem google goava como dependência, então experimentar cache de goiaba pode ser uma boa alternativa.

15
cruftex

Você pode facilmente usar imcache . Um código de amostra 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(); 
}
10
yusufaytas

Tente @Cacheable de jcabi-aspects . Com uma única anotação, você torna o resultado do método inteiro 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

8
yegor256

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

}
8
Serhii Bohutskyi

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

3
TofuBeer

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

Você pode serializar para disco, banco de dados, através de um cluster, etc ...

0
Stephen