Ricerca di una semplice cache in memoria Java [chiusa]

Sto cercando una semplice cache in memoria Java che abbia una buona concorrenza (quindi LinkedHashMap non è abbastanza buona) e che possa essere serializzata periodicamente su disco.

Una caratteristica di cui ho bisogno, ma che si è rivelata difficile da trovare, è un modo per "sbirciare" un oggetto. Con questo intendo recuperare un oggetto dalla cache senza far sì che la cache rimanga sull'oggetto più a lungo di quanto avrebbe altrimenti.

Aggiornamento: un ulteriore requisito che ho trascurato di menzionare è che devo essere in grado di modificare gli oggetti memorizzati nella cache (contengono array float) sul posto.

Qualcuno può fornire consigli?

Poiché questa domanda è stata inizialmente posta, la libreria Guava di Google ora include una cache potente e flessibile. Consiglierei di usarlo.

Ehcache è una soluzione abbastanza buona per questo e ha un modo per sbirciare ( getQuiet () è il metodo) in modo tale da non aggiornare il timestamp di inattività. Internamente, Ehcache è implementato con un set di mappe, un po 'come ConcurrentHashMap, quindi ha tipi simili di vantaggi di concorrenza.

Se hai bisogno di qualcosa di semplice, questo andrebbe bene?

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

Non salverà su disco, ma hai detto che volevi semplice ...

Collegamenti:

• Collections.synchronizedMap
• WeakHashMap

(Come ha commentato Adam, la sincronizzazione di una mappa ha un calo delle prestazioni. Non sto dicendo che l'idea non ha peli su di essa, ma sarebbe sufficiente come soluzione rapida e sporca.)

Un'altra opzione per una java cache in memoria è cache2k . Le prestazioni in memoria sono superiori a EHCache e google guava, vedere la pagina dei benchmark di cache2k .

Il modello di utilizzo è simile ad altre cache. Ecco un esempio:

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 hai google guava come dipendenza, provare guava cache, potrebbe essere una buona alternativa.

Puoi facilmente usare imcache . Di seguito è riportato un codice di esempio.

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

Prova questo:

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

}

Prova @Cacheabledagli aspetti jcabi . Con una singola annotazione rendi l'intero metodo memorizzabile nella cache:

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

Inoltre, leggi questo articolo: http://www.yegor256.com/2014/08/03/cacheable-java-annotation.html

Che ne dici di questo: https://commons.apache.org/proper/commons-jcs/ (aggiornato al nuovo indirizzo, poiché JCS è ora in Apache Commons)

Prova Ehcache ? Ti consente di collegare i tuoi algoritmi di scadenza della cache in modo da poter controllare la tua funzionalità peek.

Puoi serializzare su disco, database, su un cluster ecc ...