Mise en œuvre d'une cache à l'aide d'un java ConcurrentHashMap

J'aimerais mettre en œuvre une simple mise en cache de lourds objets dans une application java. Mais je ne peux pas comprendre comment le faire correctement.

Suis-je raté quelque chose ou ConcurrentHashMap méthodes (putIfAbsent, ...) ne sont pas suffisants et synchronisation supplémentaire est-elle nécessaire ?

Est-il un meilleur API simple (Dans la mémoire de stockage, sans config) pour ce faire ?

Je me demandais: ce sont vraiment vos exigences pour la mise en cache? Avez-vous besoin pour mettre en cache la pleine fermeture transitive de votre poids lourd de l'objet de sorte qu'il est cohérent sur l'ensemble du cluster de serveurs d'application? Si oui, c'est un non-trivial problème à résoudre, et vous feriez mieux d'utiliser un cache de la bibliothèque comme ehcache.

OriginalL'auteur Paolo1976 | 2010-01-15

14

S'il est sûr de temporairement avoir plus d'une instance pour la chose que vous essayez de cache, vous pouvez faire un "lock-free" cache comme ceci:
```
public Heavy instance(Object key) {
  Heavy info = infoMap.get(key);
  if ( info == null ) {
    //It's OK to construct a Heavy that ends up not being used
    info = new Heavy(key);
    Heavy putByOtherThreadJustNow = infoMap.putIfAbsent(key, info);
    if ( putByOtherThreadJustNow != null ) {
      //Some other thread "won"
      info = putByOtherThreadJustNow;
    }
    else {
      //This thread was the winner
    }
  }
  return info;
}
```
Plusieurs threads peuvent "race" pour créer et ajouter un élément pour la clé, mais un seul doit "gagner".

Que faire si vous voulez avoir une méthode de mise à jour qui remplace/rafraîchit l'objet lourd pour une clé donnée ?
Ou simplement l'utiliser Cartographe, et un seul thread sera jamais créer les Lourds. Si un autre thread besoins pendant qu'il est encore dans le milieu de la création, il sera tout simplement d'attendre le résultat.
Je vais laisser le droit de vote MapMaker gourous de la réponse à cette question.

OriginalL'auteur Ken
25

Plus à Ken de réponse, si la création d'un poids lourd de l'objet qui, plus tard, se jette pas n'est PAS acceptable, vous voulez vous assurer que seulement un objet est créé pour chaque clé, pour une raison quelconque), alors vous pouvez le faire en.... en fait, ne le faites pas. Ne pas le faire vous-même. Utiliser le google-collections (maintenant goyave) Cartographe de la classe:
```
Map<KeyType, HeavyData> cache = new MapMaker<KeyType, HeavyData>()
  .makeComputingMap(new Function<KeyType, HeavyData>() {
      public HeavyData apply(KeyType key) {
          return new HeavyData(key); //Guaranteed to be called ONCE for each key
      }
  });
```
Alors qu'un simple cache.get(key) juste œuvres et supprime complètement vous soucier de délicat aspects de la simultanéité et de syncrhonization.

Notez que si vous voulez ajouter un peu amateur de fonctionnalités, comme la date d'expiration, c'est juste
```
Map<....> cache = new MapMaker<....>()
  .expiration(30, TimeUnit.MINUTES)
  .makeComputingMap(.....)
```
et vous pouvez également utiliser facilement doux ou des valeurs faibles pour les clés ou les données si nécessaire (voir la Javadoc pour plus de détails)

Wow, quelle belle et élégante solution!

OriginalL'auteur Cowan

Au lieu de mettre le "gros objets" dans le cache, vous pouvez utiliser la lumière de l'usine d'objets pour créer un cache actif.

public abstract class LazyFactory implements Serializable {

  private Object _heavyObject;

  public getObject() {
    if (_heavyObject != null) return _heavyObject;
    synchronized {
      if (_heavyObject == null) _heavyObject = create();
    }
    return _heavyObject;
  }

  protected synchronized abstract Object create();
}

//here's some sample code

//create the factory, ignore negligible overhead for object creation
LazyFactory factory = new LazyFactory() {
  protected Object create() {
    //do heavy init here
    return new DbConnection();
  };
};
LazyFactory prev = map.pufIfAbsent("db", factory);
//use previous factory if available
return prev != null ? prev.getObject() : factory.getObject;

OriginalL'auteur sfussenegger

0

ConcurrentHashMap devrait être suffisant pour vos besoins putIfAbsent est thread-safe.

Pas sûr de savoir comment beaucoup plus simple que vous pouvez obtenir
```
ConcurrentMap myCache = new ConcurrentHashMap();
```
Paul

OriginalL'auteur Paul Whelan

Je me rends compte que c'est un vieux post, mais en java 8 cela peut se faire sans la création d'un potentiellement inutilisés objet lourd avec un ConcurrentHashMap.

public class ConcurrentCache4<K,V> {
    public static class HeavyObject
    {
    }

    private ConcurrentHashMap<String, HeavyObject> cache = new ConcurrentHashMap<>();

    public HeavyObject get(String key)
    {
        HeavyObject heavyObject = cache.get(key);
        if (heavyObject != null) {
            return heavyObject;
        }

        return cache.computeIfAbsent(key, k -> new HeavyObject());
    }
}

OriginalL'auteur Shane

Vous devez vous connecter pour publier un commentaire.