Facile, simple à utiliser LRU cache en java

Question

Je sais que c'est simple à mettre en œuvre, mais je veux réutiliser quelque chose qui existe déjà.

Problème que je veux résoudre, c'est que j'ai charger la configuration (à partir de XML je tiens donc à les mettre en cache) pour les différentes pages, les rôles, ... de sorte que la combinaison d'entrées peut se développer assez bien (mais dans 99% ne sera pas). Pour gérer ce 1%, je veux avoir un certains nombre maximum d'éléments dans le cache...

Jusqu'sais que j'ai trouvé org.apache.commons.les collections.carte.LRUMap dans apache commons et il semble bien, mais souhaitez vérifier aussi quelque chose d'autre. Toutes les recommandations?

Answer 1

Vous pouvez utiliser une LinkedHashMap (Java 1.4+) :

Le code de exampledepot.com:

// Create cache
final int MAX_ENTRIES = 100;
Map cache = new LinkedHashMap(MAX_ENTRIES+1, .75F, true) {
    // This method is called just after a new entry has been added
    public boolean removeEldestEntry(Map.Entry eldest) {
        return size() > MAX_ENTRIES;
    }
};

// Add to cache
Object key = "key";
cache.put(key, object);

// Get object
Object o = cache.get(key);
if (o == null && !cache.containsKey(key)) {
    // Object not in cache. If null is not a possible value in the cache,
    // the call to cache.contains(key) is not needed
}

// If the cache is to be used by multiple threads,
// the cache must be wrapped with code to synchronize the methods
cache = (Map)Collections.synchronizedMap(cache);

Answer 2

C'est une vieille question, mais pour la postérité je voulais à la liste ConcurrentLinkedHashMap, qui est thread-safe, contrairement à LRUMap. L'utilisation est très facile:

ConcurrentMap<K, V> cache = new ConcurrentLinkedHashMap.Builder<K, V>()
    .maximumWeightedCapacity(1000)
    .build();

La documentation a quelques bons exemples, comme la façon de faire de la LRU, la taille du cache de base au lieu du nombre d'éléments de base.

Answer 3

Voici mon application qui me permet de garder un nombre optimal d'éléments en mémoire.

Le point est que je n'ai pas besoin de garder une trace de ce que les objets sont actuellement utilisés depuis que je suis en utilisant une combinaison d'une LinkedHashMap pour le MRU objets et un WeakHashMap pour la LRU objets. De sorte que la capacité de mise en cache n'est pas moins de MRU taille ainsi que la GC, me permet de le garder. Chaque fois que les objets de tomber de la MRU, ils vont à la LRU, aussi longtemps que le GC va les avoir.

public class Cache<K,V> {
final Map<K,V> MRUdata;
final Map<K,V> LRUdata;

public Cache(final int capacity)
{
    LRUdata = new WeakHashMap<K, V>();

    MRUdata = new LinkedHashMap<K, V>(capacity+1, 1.0f, true) {
        protected boolean removeEldestEntry(Map.Entry<K,V> entry)
        {
            if (this.size() > capacity) {
                LRUdata.put(entry.getKey(), entry.getValue());
                return true;
            }
            return false;
        };
    };
}

public synchronized V tryGet(K key)
{
    V value = MRUdata.get(key);
    if (value!=null)
        return value;
    value = LRUdata.get(key);
    if (value!=null) {
        LRUdata.remove(key);
        MRUdata.put(key, value);
    }
    return value;
}

public synchronized void set(K key, V value)
{
    LRUdata.remove(key);
    MRUdata.put(key, value);
}
}

Answer 4

J'ai également eu le même problème et je n'ai pas trouvé toutes les bonnes librairies... j'ai donc créé mon propre.

simplelrucache fournit des threads, très simple, non-distribués LRU, la mise en cache avec un TTL de soutien. Il propose deux implémentations

• Simultanées basé sur ConcurrentLinkedHashMap
• Synchronisés, basé sur la LinkedHashMap

Vous pouvez le trouver ici.

Answer 5

Ici est très simple et facile à utiliser LRU cache en Java. Même si il est court et simple, c'est la qualité de la production. Le code est expliqué (voir le fichier README.md) et a des tests unitaires.