Quelle est la différence entre ConcurrentHashMap et des Collections.synchronizedMap(Map)?

╔═══════════════╦═══════════════════╦═══════════════════╦═════════════════════╗
║   Property    ║     HashMap       ║    Hashtable      ║  ConcurrentHashMap  ║
╠═══════════════╬═══════════════════╬═══════════════════╩═════════════════════╣ 
║      Null     ║     allowed       ║              not allowed                ║
║  values/keys  ║                   ║                                         ║
╠═══════════════╬═══════════════════╬═════════════════════════════════════════╣
║Is thread-safe ║       no          ║                  yes                    ║
╠═══════════════╬═══════════════════╬═══════════════════╦═════════════════════╣
║     Lock      ║       not         ║ locks the whole   ║ locks the portion   ║        
║  mechanism    ║    applicable     ║       map         ║                     ║ 
╠═══════════════╬═══════════════════╩═══════════════════╬═════════════════════╣
║   Iterator    ║               fail-fast               ║ weakly consistent   ║ 
╚═══════════════╩═══════════════════════════════════════╩═════════════════════╝

Concernant le mécanisme de verrouillage:
Hashtable verrouille l'objet, tandis que ConcurrentHashMap serrures seul le seau.

ConcurrentHashMap est préférable si vous pouvez l'utiliser même si elle nécessite au moins la version Java 5.

Il est conçu à l'échelle ainsi lorsqu'il est utilisé par plusieurs threads. Les performances peuvent être légèrement plus pauvres lorsqu'un seul thread accède à la Carte à un moment, mais nettement mieux lorsque plusieurs threads accèdent à la carte en même temps.

J'ai trouvé un l'entrée de blog qui reproduit un tableau de l'excellent livre Java De La Simultanéité Dans La Pratique, que je recommande absolument.

Collections.synchronizedMap sens vraiment que si vous avez besoin d'envelopper de la carte avec certaines autres caractéristiques, peut-être une sorte de commandé la carte, comme un TreeMap.

• Hashtable et ConcurrentHashMap ne permettent pas null clés ou null valeurs.

• Collections.synchronizedMap(Map) synchronise tous opérations (get, put, size, etc).

• ConcurrentHashMap prise en charge de la concurrence des récupérations, et réglable de simultanéité prévu pour les mises à jour.

Comme d'habitude, il y a simultanéité-les frais généraux--vitesse de concessions à faire. Vous avez vraiment besoin de considérer le détail de la simultanéité des exigences de votre application pour prendre une décision, puis de tester votre code pour voir si elle est assez bonne.

Synchronisé Carte:

Synchronisé Carte est également pas très différent de la table de hachage et offre des performances similaires en simultané de programmes Java. Seule différence entre la table de hachage et SynchronizedMap est que SynchronizedMap n'est pas un héritage et que vous pouvez placer n'importe quelle Carte de créer il est synchronisé version à l'aide de Collections.synchronizedMap() la méthode.

ConcurrentHashMap:

La ConcurrentHashMap classe fournit en même temps une version de la norme HashMap. C'est une amélioration sur le synchronizedMap fonctionnalités fournies dans les Collections de la classe.

Contrairement à la table de hachage et la synchronisation de la Carte, il n'a jamais serrures ensemble de la Carte, au lieu de cela, il divise la carte en segments et le verrouillage se fait sur ceux-ci. Il fonctionnera mieux si le nombre de threads de lecture sont plus importants que le nombre de threads d'écriture.

ConcurrentHashMap par défaut est divisé en 16 régions et les serrures sont appliquées. Cette valeur par défaut peut être défini lors de l'initialisation d'un ConcurrentHashMap instance. Lors de la configuration de données dans un segment particulier, le blocage de ce segment est obtenu. Cela signifie que deux mises à jour peuvent toujours exécuter simultanément en toute sécurité si ils affectent distinct des seaux, et donc la réduction de verrouillage et ainsi de maximiser le rendement.

ConcurrentHashMap ne jette pas un ConcurrentModificationException

ConcurrentHashMap ne jette pas un ConcurrentModificationException si un thread tente de modifier tandis que l'autre est une itération de plus il

Différence entre synchornizedMap et ConcurrentHashMap

Collections.synchornizedMap(HashMap) va retourner une collection qui est presque l'équivalent de la table de hachage, où chaque opération sur la Carte est verrouillée sur la Carte de l'objet, tandis que dans le cas de ConcurrentHashMap, le fil de sécurité est obtenu en divisant l'ensemble de la Carte dans différents partition basée sur niveau de simultanéité et seulement verrouillage notamment partie à la place de verrouillage de la totalité de la Carte.

ConcurrentHashMap ne pas autoriser les valeurs null clés ou des valeurs nulles, tout synchronisé HashMap permet clés null.

Liens similaires

Link1

Link2

Comparaison Des Performances

Voici quelques-uns :

1) ConcurrentHashMap verrouille uniquement la partie de la Carte, mais SynchronizedMap serrures ensemble de la Carte.

2) ConcurrentHashMap a une meilleure performance sur SynchronizedMap et plus évolutif.

3) En cas de pluralité de lecteur et de l'écrivain ConcurrentHashMap est le meilleur choix.

Ce texte est de Différence entre ConcurrentHashMap et table de hachage en Java

ConcurrentHashMap

• Vous devez utiliser ConcurrentHashMap lorsque vous avez besoin de très haute simultanéité dans votre projet.
• Il est thread-safe, sans synchronisation de l'ensemble de la carte.
• Lit peuvent arriver très vite alors que l'écriture est réalisée avec une serrure.
• Il n'y a pas de blocage au niveau de l'objet.
• Le verrouillage est beaucoup plus fine granularité à une hashmap seau niveau.
• ConcurrentHashMap ne jette pas un ConcurrentModificationException si un thread tente de modifier tandis que l'autre est une itération sur elle.
• ConcurrentHashMap utilise multitude de serrures.

SynchronizedHashMap

• De synchronisation au niveau de l'Objet.
• Chaque opération de lecture/écriture doit acquérir de verrouillage.
• Le verrouillage de l'ensemble de la collection est une surcharge de performance.
• Essentiellement, cela donne accès à un seul thread à la totalité de la carte & bloque tous les autres threads.
• Il peut causer la discorde.
• SynchronizedHashMap retourne un Itérateur, qui ne parvient pas rapide sur les modifications simultanées.

source

Il y a une critique de la fonction à noter à propos de ConcurrentHashMap autres que la simultanéité fonctionnalités qu'il propose, qui est fail-safe itérateur. J'ai vu des développeurs utilisant ConcurrentHashMap simplement parce qu'ils veulent modifier la entryset - mettre/enlever lors de l'itération sur elle.
Collections.synchronizedMap(Map) ne fournit pas de fail-safe itérateur, mais il fournit fail-fast itérateur à la place. fail-fast itérateurs utilise instantané de la taille de la carte qui ne peut pas être modifié au cours d'une itération.

En général, si vous souhaitez utiliser le ConcurrentHashMap assurez-vous que vous êtes prêt à manquer "mises à jour"
(c'est à dire de l'impression du contenu de la table de hachage n'est pas de s'assurer qu'il va imprimer la Carte à jour) et de l'utilisation des Api comme CyclicBarrier pour assurer la cohérence au sein de votre programme de cycle de vie.

En plus de ce qui a été suggéré, j'aimerais afficher le code source liées à SynchronizedMap.

De faire un Map thread-safe, nous pouvons utiliser Collections.synchronizedMap instruction et l'entrée de la carte de l'instance en tant que paramètre.

La mise en œuvre de synchronizedMap dans Collections est comme ci-dessous

   public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
        return new SynchronizedMap<>(m);
    }

Comme vous pouvez le voir, l'entrée Map objet est enveloppé par le SynchronizedMap objet.

Nous allons creuser dans la mise en œuvre de SynchronizedMap ,

 private static class SynchronizedMap<K,V>
implements Map<K,V>, Serializable {
private static final long serialVersionUID = 1978198479659022715L;
private final Map<K,V> m;     //Backing Map
final Object      mutex;        //Object on which to synchronize
SynchronizedMap(Map<K,V> m) {
this.m = Objects.requireNonNull(m);
mutex = this;
}
SynchronizedMap(Map<K,V> m, Object mutex) {
this.m = m;
this.mutex = mutex;
}
public int size() {
synchronized (mutex) {return m.size();}
}
public boolean isEmpty() {
synchronized (mutex) {return m.isEmpty();}
}
public boolean containsKey(Object key) {
synchronized (mutex) {return m.containsKey(key);}
}
public boolean containsValue(Object value) {
synchronized (mutex) {return m.containsValue(value);}
}
public V get(Object key) {
synchronized (mutex) {return m.get(key);}
}
public V put(K key, V value) {
synchronized (mutex) {return m.put(key, value);}
}
public V remove(Object key) {
synchronized (mutex) {return m.remove(key);}
}
public void putAll(Map<? extends K, ? extends V> map) {
synchronized (mutex) {m.putAll(map);}
}
public void clear() {
synchronized (mutex) {m.clear();}
}
private transient Set<K> keySet;
private transient Set<Map.Entry<K,V>> entrySet;
private transient Collection<V> values;
public Set<K> keySet() {
synchronized (mutex) {
if (keySet==null)
keySet = new SynchronizedSet<>(m.keySet(), mutex);
return keySet;
}
}
public Set<Map.Entry<K,V>> entrySet() {
synchronized (mutex) {
if (entrySet==null)
entrySet = new SynchronizedSet<>(m.entrySet(), mutex);
return entrySet;
}
}
public Collection<V> values() {
synchronized (mutex) {
if (values==null)
values = new SynchronizedCollection<>(m.values(), mutex);
return values;
}
}
public boolean equals(Object o) {
if (this == o)
return true;
synchronized (mutex) {return m.equals(o);}
}
public int hashCode() {
synchronized (mutex) {return m.hashCode();}
}
public String toString() {
synchronized (mutex) {return m.toString();}
}
//Override default methods in Map
@Override
public V getOrDefault(Object k, V defaultValue) {
synchronized (mutex) {return m.getOrDefault(k, defaultValue);}
}
@Override
public void forEach(BiConsumer<? super K, ? super V> action) {
synchronized (mutex) {m.forEach(action);}
}
@Override
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
synchronized (mutex) {m.replaceAll(function);}
}
@Override
public V putIfAbsent(K key, V value) {
synchronized (mutex) {return m.putIfAbsent(key, value);}
}
@Override
public boolean remove(Object key, Object value) {
synchronized (mutex) {return m.remove(key, value);}
}
@Override
public boolean replace(K key, V oldValue, V newValue) {
synchronized (mutex) {return m.replace(key, oldValue, newValue);}
}
@Override
public V replace(K key, V value) {
synchronized (mutex) {return m.replace(key, value);}
}
@Override
public V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
synchronized (mutex) {return m.computeIfAbsent(key, mappingFunction);}
}
@Override
public V computeIfPresent(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
synchronized (mutex) {return m.computeIfPresent(key, remappingFunction);}
}
@Override
public V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
synchronized (mutex) {return m.compute(key, remappingFunction);}
}
@Override
public V merge(K key, V value,
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
synchronized (mutex) {return m.merge(key, value, remappingFunction);}
}
private void writeObject(ObjectOutputStream s) throws IOException {
synchronized (mutex) {s.defaultWriteObject();}
}
}

Ce SynchronizedMap ne peuvent être résumées comme l'ajout d'un verrou unique à la méthode principale de l'entrée Map objet. Méthode tous gardé par le verrou ne peut pas être accédé par plusieurs threads en même temps. Cela signifie que les opérations normales comme put et get peut être exécuté par un seul thread en même temps pour toutes les données de la Map objet.

Il fait le Map objet thread-safe maintenant, mais la performance peut devenir un problème dans certains scénarios.

La ConcurrentMap est beaucoup plus compliqué dans la mise en œuvre, nous pouvons nous référer à La construction d'une meilleure HashMap pour plus de détails. En un mot, il est mis en œuvre en tenant à la fois thread-safe et de la performance en considération.