Recherche d'un cache Java en mémoire simple

Question

Je suis à la recherche d'un simple Java cache en mémoire qui a bien de la concurrence (donc LinkedHashMap n'est pas assez bon), et qui peut être sérialisé sur le disque régulièrement.

Une fonctionnalité dont j'ai besoin, mais qui a été difficile à trouver, est une manière de "coup d'oeil" à un objet. Par cela, je veux dire récupérer un objet de la cache sans causer le cache pour tenir à l'objet plus longtemps qu'elle aurait du.

Mise à jour: Une exigence supplémentaire, j'ai oublié de mentionner, c'est que j'ai besoin d'être en mesure de modifier les objets mis en cache (ils contiennent float tableaux) en place.

Quelqu'un peut-il fournir toutes les recommandations?

Answer 1

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

Answer 2

Ehcache est une très bonne solution pour cela et a un moyen de jeter un coup d'œil ( getQuiet () est la méthode) de sorte qu'il ne mette pas à jour l'horodatage d'inactivité. En interne, Ehcache est implémenté avec un ensemble de cartes, un peu comme ConcurrentHashMap, ce qui lui confère des avantages similaires en termes de concurrence.

Answer 3

Si tu as besoin de quelque chose de simple, serait-il adapter le projet de loi?

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

Il l'habitude de les enregistrer sur le disque, mais vous avez dit que vous vouliez simple...

Liens:

• Les Collections.synchronizedMap
• WeakHashMap

(Comme Adam a commenté, de synchroniser une carte a un gain de performance. Ne pas dire l'idée n'a pas de poils, mais il suffit d'un rapide et sale de la solution.)

Answer 4

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

Answer 5

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

}