Recherche d'un cache Java en mémoire simple [fermé]

Je recherche un cache Java en mémoire simple qui a une bonne concurrence (donc LinkedHashMap n'est pas assez bon), et qui peut être sérialisé sur le disque périodiquement.

Une fonctionnalité dont j'ai besoin, mais qui s'est avérée difficile à trouver, est un moyen de «jeter un coup d'œil» sur un objet. J'entends par là récupérer un objet du cache sans que le cache ne retienne l'objet plus longtemps qu'il ne l'aurait autrement.

Mise à jour: Une exigence supplémentaire que j'ai négligée de mentionner est que je dois être en mesure de modifier les objets mis en cache (ils contiennent des tableaux flottants) sur place.

Quelqu'un peut-il fournir des recommandations?

Depuis que cette question a été posée à l'origine, la bibliothèque Guava de Google comprend désormais un cache puissant et flexible. Je recommanderais d'utiliser ceci.

Ehcache est une très bonne solution pour cela et a un moyen de voir ( getQuiet () est la méthode) de sorte qu'il ne met pas à jour l'horodatage d'inactivité. En interne, Ehcache est implémenté avec un ensemble de cartes, un peu comme ConcurrentHashMap, il présente donc des avantages similaires en matière de concurrence.

Si vous avez besoin de quelque chose de simple, cela conviendrait-il?

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

Il ne sera pas enregistré sur le disque, mais vous avez dit que vous vouliez simple ...

Liens:

• Collections.synchronizedMap
• WeakHashMap

(Comme Adam l'a commenté, la synchronisation d'une carte a un impact sur les performances. Ne pas dire que l'idée n'a pas de poils dessus, mais qu'elle suffirait comme solution rapide et sale.)

Une autre option pour un cache java en mémoire est cache2k . Les performances en mémoire sont supérieures à EHCache et google guava, voir la page des tests de cache2k .

Le modèle d'utilisation est similaire à celui des autres caches. Voici un exemple:

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 vous avez google goyave comme dépendance, essayer le cache de goyave peut être une bonne alternative.

Vous pouvez facilement utiliser imcache . Un exemple de code est ci-dessous.

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

Essaye ça:

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

}

Essayez @Cacheablede jcabi-aspects . Avec une seule annotation, vous pouvez mettre en cache l'ensemble du résultat de la méthode en mémoire:

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

Lisez également cet article: http://www.yegor256.com/2014/08/03/cacheable-java-annotation.html

Que diriez-vous de ceci: https://commons.apache.org/proper/commons-jcs/ (mis à jour à la nouvelle adresse, car JCS est maintenant dans Apache Commons)

Essayez Ehcache ? Il vous permet de brancher vos propres algorithmes d'expiration de mise en cache afin que vous puissiez contrôler vos fonctionnalités d'aperçu.

Vous pouvez sérialiser sur disque, base de données, sur un cluster, etc.