Carte / cache basée sur le temps Java avec des clés qui expirent [fermé]

L'un d'entre vous connaît-il une carte Java ou un magasin de données standard similaire qui purge automatiquement les entrées après un délai donné? Cela signifie le vieillissement, où les anciennes entrées expirées «vieillissent» automatiquement.

De préférence dans une bibliothèque open source accessible via Maven?

Je connais des moyens d'implémenter la fonctionnalité moi-même et je l'ai fait plusieurs fois dans le passé, donc je ne demande pas de conseils à cet égard, mais des pointeurs vers une bonne implémentation de référence.

Les solutions basées sur WeakReference comme WeakHashMap ne sont pas une option, car mes clés sont probablement des chaînes non internes et je veux un délai configurable qui ne dépend pas du garbage collector.

Ehcache est également une option sur laquelle je ne voudrais pas compter car il a besoin de fichiers de configuration externes. Je recherche une solution uniquement codée.

Oui. Google Collections, ou Guava comme il est nommé, a maintenant quelque chose appelé MapMaker qui peut faire exactement cela.

ConcurrentMap<Key, Graph> graphs = new MapMaker()
   .concurrencyLevel(4)
   .softKeys()
   .weakValues()
   .maximumSize(10000)
   .expiration(10, TimeUnit.MINUTES)
   .makeComputingMap(
       new Function<Key, Graph>() {
         public Graph apply(Key key) {
           return createExpensiveGraph(key);
         }
       });

Mettre à jour:

À partir de la goyave 10.0 (publiée le 28 septembre 2011), beaucoup de ces méthodes MapMaker sont obsolètes au profit du nouveau CacheBuilder :

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    .maximumSize(10000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(
        new CacheLoader<Key, Graph>() {
          public Graph load(Key key) throws AnyException {
            return createExpensiveGraph(key);
          }
        });

Il s'agit d'un exemple d'implémentation que j'ai fait pour la même exigence et la concurrence fonctionne bien. Pourrait être utile à quelqu'un.

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 
 * @author Vivekananthan M
 *
 * @param <K>
 * @param <V>
 */
public class WeakConcurrentHashMap<K, V> extends ConcurrentHashMap<K, V> {

    private static final long serialVersionUID = 1L;

    private Map<K, Long> timeMap = new ConcurrentHashMap<K, Long>();
    private long expiryInMillis = 1000;
    private static final SimpleDateFormat sdf = new SimpleDateFormat("hh:mm:ss:SSS");

    public WeakConcurrentHashMap() {
        initialize();
    }

    public WeakConcurrentHashMap(long expiryInMillis) {
        this.expiryInMillis = expiryInMillis;
        initialize();
    }

    void initialize() {
        new CleanerThread().start();
    }

    @Override
    public V put(K key, V value) {
        Date date = new Date();
        timeMap.put(key, date.getTime());
        System.out.println("Inserting : " + sdf.format(date) + " : " + key + " : " + value);
        V returnVal = super.put(key, value);
        return returnVal;
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        for (K key : m.keySet()) {
            put(key, m.get(key));
        }
    }

    @Override
    public V putIfAbsent(K key, V value) {
        if (!containsKey(key))
            return put(key, value);
        else
            return get(key);
    }

    class CleanerThread extends Thread {
        @Override
        public void run() {
            System.out.println("Initiating Cleaner Thread..");
            while (true) {
                cleanMap();
                try {
                    Thread.sleep(expiryInMillis / 2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        private void cleanMap() {
            long currentTime = new Date().getTime();
            for (K key : timeMap.keySet()) {
                if (currentTime > (timeMap.get(key) + expiryInMillis)) {
                    V value = remove(key);
                    timeMap.remove(key);
                    System.out.println("Removing : " + sdf.format(new Date()) + " : " + key + " : " + value);
                }
            }
        }
    }
}

Git Repo Link (avec implémentation du récepteur)

https://github.com/vivekjustthink/WeakConcurrentHashMap

À votre santé!!

Vous pouvez essayer mon implémentation d'une carte de hachage à expiration automatique. Cette implémentation n'utilise pas de threads pour supprimer les entrées expirées, mais utilise à la place DelayQueue qui est nettoyée à chaque opération.

Apache Commons a un décorateur pour que les entrées de la carte expirent: PassiveExpiringMap C'est plus simple que les caches de Guava.

PS attention, ce n'est pas synchronisé.

Cela ressemble à ehcache est exagéré pour ce que vous voulez, mais notez qu'il n'a pas besoin de fichiers de configuration externes.

C'est généralement une bonne idée de déplacer la configuration dans des fichiers de configuration déclaratifs (vous n'avez donc pas besoin de recompiler lorsqu'une nouvelle installation nécessite un délai d'expiration différent), mais ce n'est pas du tout requis, vous pouvez toujours le configurer par programme. http://www.ehcache.org/documentation/user-guide/configuration

Les collections Google (goyave) ont le MapMaker dans lequel vous pouvez définir un délai (pour l'expiration) et vous pouvez utiliser une référence douce ou faible lorsque vous choisissez en utilisant une méthode d'usine pour créer des instances de votre choix.

vous pouvez essayer la carte expirante http://www.java2s.com/Code/Java/Collections-Data-Structure/ExpiringMap.htm une classe du projet Apache MINA

Si quelqu'un a besoin d'une chose simple, voici un simple jeu d'expiration de clé. Il peut être facilement converti en carte.

public class CacheSet<K> {
    public static final int TIME_OUT = 86400 * 1000;

    LinkedHashMap<K, Hit> linkedHashMap = new LinkedHashMap<K, Hit>() {
        @Override
        protected boolean removeEldestEntry(Map.Entry<K, Hit> eldest) {
            final long time = System.currentTimeMillis();
            if( time - eldest.getValue().time > TIME_OUT) {
                Iterator<Hit> i = values().iterator();

                i.next();
                do {
                    i.remove();
                } while( i.hasNext() && time - i.next().time > TIME_OUT );
            }
            return false;
        }
    };


    public boolean putIfNotExists(K key) {
        Hit value = linkedHashMap.get(key);
        if( value != null ) {
            return false;
        }

        linkedHashMap.put(key, new Hit());
        return true;
    }

    private static class Hit {
        final long time;


        Hit() {
            this.time = System.currentTimeMillis();
        }
    }
}

En règle générale, un cache doit conserver les objets quelque temps et doit en exposer un peu plus tard. Le moment idéal pour tenir un objet dépend du cas d'utilisation. Je voulais que cette chose soit simple, sans fils ni ordonnanceurs. Cette approche fonctionne pour moi. Contrairement à SoftReferences, les objets sont garantis disponibles pendant un minimum de temps. Cependant, ils ne restent pas en mémoire jusqu'à ce que le soleil se transforme en une géante rouge .

Comme exemple d'utilisation, pensez à un système qui répond lentement et qui pourra vérifier si une demande a été effectuée assez récemment, et dans ce cas ne pas effectuer l'action demandée deux fois, même si un utilisateur agité appuie plusieurs fois sur le bouton. Mais, si la même action est demandée quelque temps plus tard, elle doit être exécutée à nouveau.

class Cache<T> {
    long avg, count, created, max, min;
    Map<T, Long> map = new HashMap<T, Long>();

    /**
     * @param min   minimal time [ns] to hold an object
     * @param max   maximal time [ns] to hold an object
     */
    Cache(long min, long max) {
        created = System.nanoTime();
        this.min = min;
        this.max = max;
        avg = (min + max) / 2;
    }

    boolean add(T e) {
        boolean result = map.put(e, Long.valueOf(System.nanoTime())) != null;
        onAccess();
        return result;
    }

    boolean contains(Object o) {
        boolean result = map.containsKey(o);
        onAccess();
        return result;
    }

    private void onAccess() {
        count++;
        long now = System.nanoTime();
        for (Iterator<Entry<T, Long>> it = map.entrySet().iterator(); it.hasNext();) {
            long t = it.next().getValue();
            if (now > t + min && (now > t + max || now + (now - created) / count > t + avg)) {
                it.remove();
            }
        }
    }
}

Le cache de goyave est facile à mettre en œuvre. Nous pouvons expirer la clé sur une base de temps en utilisant le cache de goyave. J'ai lu entièrement le post et ci-dessous donne la clé de mon étude.

cache = CacheBuilder.newBuilder().refreshAfterWrite(2,TimeUnit.SECONDS).
              build(new CacheLoader<String, String>(){
                @Override
                public String load(String arg0) throws Exception {
                    // TODO Auto-generated method stub
                    return addcache(arg0);
                }

              }

Référence: exemple de cache de goyave