Volatile HashMap vs ConcurrentHashMap

J'ai une classe de cache qui contient un volatile HashMap<T> pour stocker les éléments du cache.

Je suis curieux de savoir quelles seraient les conséquences d'un changement de volatile HashMap à ConcurrentHashMap?

Aurais-je le gain de augmentation de la performance? Ce cache est readonly cache.

Quelle serait la meilleure option pour les utiliser? juste HashMap? Le Cache est rempli sur un intervalle.

source d'informationauteur DarthVader | 2012-04-27

  1. 31

    Tout d'abord, il semble que vous ne comprenez pas ce que le volatile mot clé n'est. Il permet de s'assurer que si la valeur de référence détenus par la variable déclarée volatile changements, d'autres threads de le voir plutôt que d'avoir une copie mise en cache. Il n'a rien à voir avec le fil de sécurité en ce qui concerne l'accès à l' HashMap

    Compte tenu de cela et du fait que vous dites que le HashMap est en lecture seule ... vous avez certainement n'avez pas besoin d'utiliser quoi que ce soit qui fournit des threads de sécurité, y compris un ConcurrentHashMap

    Modifier pour ajouter: Votre dernière modification vous maintenant de dire "Le cache est rempli sur un intervalle"

    Ce n'est pas en lecture seule alors, est-il?

    Si vous allez avoir des threads de lecture tout vous êtes à la rédaction (mise à jour de l'existant HashMap), alors vous devez utiliser un ConcurrentHashMapoui.

    Si vous remplissez un tout nouveau HashMap puis l'affecter à la variable existante, vous utilisez volatile

  2. 6

    Vous dire que le cache est en lecture seule, mais aussi d'être mis à jour sur un intervalle qui semble contradictoire.

    Si l'ensemble de la cache est mis à jour sur un intervalle, j'aimerais continuer à utiliser le volatile.
    Le volatile assurez-vous que la mise à jour de la carte en toute sécurité est publié.

    public final class  Cache
{
   private volatile Map<?,?> cache;

   private void mapUpdate() {
      Map<?,?> newCache = new HashMap<>();

      //populate the map

      //update the reference with an immutable collection
      cache = Collections.unmodifiableMap(newCache);
   }
}

    Si l'intervalle de mise à jour est en train de modifier le cache même, alors vous voudrez probablement utiliser une ConcurrentHashMap, ou copie de la carte, mise à jour de la copie, et la mise à jour de la référence.

    public final class  Cache
{
   private volatile Map<?,?> cache;

   private void mapUpdate() {
      Map<?,?> newCache = new HashMap<>(cache);

      //update the map

      //update the reference with an immutable collection
      cache = Collections.unmodifiableMap(newCache);
   }
}