Alla ricerca di una semplice cache in memoria Java

Question

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

Una funzione di cui ho bisogno, ma che è stato difficile trovare, è un modo per "sbirciare" su un oggetto. Con questo intendo il recupero di un oggetto dalla cache senza che la cache rimanga sull'oggetto più a lungo di quanto non avrebbe altrimenti.

Aggiornamento: Un ulteriore requisito che ho dimenticato di menzionare è che devo essere in grado di modificare gli oggetti memorizzati nella cache (contengono matrici mobili) sul posto.

Qualcuno può fornire qualche suggerimento?

Answer 1

Dal momento che questa domanda è stato originariamente chiesto, Google's Guava library include ora una cache potente e flessibile. Consiglierei di usare questo.

Answer 2

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

Answer 3

Ehcache è una bella buona soluzione per questo e ha un modo di sbirciare (getQuiet() è il metodo) in modo tale che non aggiorna il timestamp inattivo. Internamente, Ehcache è implementato con una serie di mappe, un po 'come ConcurrentHashMap, quindi ha simili vantaggi di concorrenza.

Answer 4

Provare Ehcache? Ti consente di collegare i tuoi algoritmi di scadenza del caching in modo da poter controllare la tua funzionalità di sbirciatina.

È possibile serializzare su disco, banca dati, attraverso un cluster ecc ...

Answer 5

Se stai bisogno di qualcosa di semplice, sarebbe questa misura la fattura?

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

E 'abitudine salvare su disco, ma hai detto che volevi semplice ...

vicini:

• Collections.synchronizedMap
• WeakHashMap

(Come ha commentato Adam, la sincronizzazione di una mappa ha un impatto sulle prestazioni. Non dire che l'idea non abbia i capelli su di me t, ma sarebbe sufficiente come una soluzione rapida e sporca)

Answer 6

Prova questa:.

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 7

È possibile utilizzare facilmente imcache. Un codice di esempio è sotto.

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

Answer 8

Un'altra opzione per una cache java in memoria è cache2k. Le prestazioni in memoria sono superiori a EHCache e google guava, vedere cache2k benchmarks page.

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

Answer 9

Provare @Cacheable da jcabi-aspects. Con una sola annotazione si effettua l'intero risultato metodo cacheable in memoria:

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

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