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

Question

J'ai une carte qui doit être modifiée par plusieurs threads simultanément.

Il semble qu'il existe trois implémentations différentes de Map synchronisé dans l'API Java :

• Hashtable
• Collections.synchronizedMap(Map)
• ConcurrentHashMap

D'après ce que j'ai compris, Hashtable est une ancienne implémentation (extension de l'obsolète Dictionary ), qui a été adaptée par la suite pour correspondre à la classe Map l'interface. Bien qu'elle es synchronisée, elle semble avoir de sérieuses les problèmes d'évolutivité et est déconseillé pour les nouveaux projets.

Mais qu'en est-il des deux autres ? Quelles sont les différences entre les cartes renvoyées par Collections.synchronizedMap(Map) y ConcurrentHashMap s ? Laquelle correspond à quelle situation ?

Answer 1

Pour vos besoins, utilisez ConcurrentHashMap . Il permet la modification simultanée de la carte à partir de plusieurs threads sans qu'il soit nécessaire de les bloquer. Collections.synchronizedMap(map) crée une carte bloquante qui dégrade les performances, mais assure la cohérence (si elle est utilisée correctement).

Utilisez la deuxième option si vous devez assurer la cohérence des données et si chaque thread doit disposer d'une vue actualisée de la carte. Utilisez la première option si les performances sont essentielles et si chaque thread n'insère que des données dans la carte, les lectures étant moins fréquentes.

Answer 2

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

En ce qui concerne le mécanisme de verrouillage : Hashtable verrouille l'objet , tandis que ConcurrentHashMap serrures seulement le seau .

Answer 3

Les "problèmes d'évolutivité" pour les Hashtable sont présents exactement de la même manière dans Collections.synchronizedMap(Map) - ils utilisent une synchronisation très simple, ce qui signifie qu'un seul thread peut accéder à la carte en même temps.

Ce n'est pas vraiment un problème lorsque vous effectuez de simples insertions et consultations (à moins que vous ne le fassiez de manière extrêmement intensive), mais cela devient un gros problème lorsque vous devez itérer sur l'ensemble de la carte, ce qui peut prendre beaucoup de temps pour une grande carte - pendant qu'un thread effectue cette opération, tous les autres doivent attendre s'ils veulent insérer ou consulter quelque chose.

En ConcurrentHashMap utilise des techniques très sophistiquées pour réduire le besoin de synchronisation et permettre l'accès à la lecture en parallèle par plusieurs threads sans synchronisation. Iterator qui ne nécessite aucune synchronisation et permet même de modifier la carte pendant l'itération (bien qu'elle ne garantisse pas que les éléments insérés pendant l'itération seront renvoyés).

Answer 4

ConcurrentHashMap est préférable lorsque vous pouvez l'utiliser - bien qu'il nécessite au moins Java 5.

Il est conçu pour s'adapter à l'utilisation de plusieurs threads. Les performances peuvent être légèrement inférieures lorsqu'un seul thread accède à la carte à la fois, mais elles sont nettement meilleures lorsque plusieurs threads accèdent à la carte simultanément.

J'ai trouvé un article de blog qui reproduit un tableau tiré de l'excellent livre Concurrence Java en pratique que je recommande vivement.

Collections.synchronizedMap n'a de sens que si vous avez besoin d'envelopper une carte avec d'autres caractéristiques, peut-être une sorte de carte ordonnée, comme une TreeMap.

Answer 5

En ConcurrentHashMap le verrouillage est appliqué à un segment au lieu d'une carte entière. Chaque segment gère sa propre table de hachage interne. Le verrou n'est appliqué que pour les opérations de mise à jour. Collections.synchronizedMap(Map) synchronise l'ensemble de la carte.