Aller au contenu

Java — HashMap vs ConcurrentHashMap (Concurrence & performance)

Comprendre la différence entre HashMap et ConcurrentHashMap est essentiel dès qu’on travaille avec plusieurs threads. C’est un sujet très fréquent et directement lié aux performances et à la stabilité des applications.

Idée simple

HashMap

  • ❌ pas thread-safe
  • ✔️ très rapide en mono-thread

ConcurrentHashMap

  • ✔️ thread-safe
  • ✔️ optimisé pour la concurrence

Problème avec HashMap

Map<String, Integer> map = new HashMap<>();

En multithreading :

  • données corrompues
  • résultats imprévisibles
  • dans certains cas extrêmes → boucle infinie

Solution : ConcurrentHashMap

Map<String, Integer> map = new ConcurrentHashMap<>();

Permet :

  • accès concurrent sécurisé
  • bonnes performances
  • utilisation en environnement multi-thread

⚡ Différence clé

HashMap

  • aucune synchronisation
  • rapide
  • dangereux en multi-thread

ConcurrentHashMap

  • synchronisation fine (granulaire)
  • pas de blocage global
  • meilleure scalabilité

Pourquoi pas juste synchronized ?

Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());

Problème :

  • verrou global (lock sur toute la map)
  • forte contention
  • performances réduites

ConcurrentHashMap est préférable car :

  • verrouillage partiel (par zones internes)
  • plusieurs threads peuvent travailler en parallèle

Résumé simple

Feature HashMap ConcurrentHashMap
thread-safe ❌ ✔️
performance ✔️ ✔️✔️ (multi-thread)
type de lock ❌ fin (granulaire)

Pièges fréquents

  • utiliser HashMap en multithread
  • penser que synchronizedMap est optimal
  • ignorer la contention

Questions classiques

Q1

HashMap est-il thread-safe ? Non

Q2

ConcurrentHashMap utilise quel type de verrou ?

  • A. lock global
  • B. lock fin
  • C. aucun lock

Réponse : B

Q3

Pourquoi éviter synchronizedMap ?

car il utilise un lock global, ce qui augmente la contention et réduit les performances

Q4

Quel choix pour une application multi-thread (ex: trading) ?

ConcurrentHashMap

À retenir

  • HashMap est rapide mais dangereux en multi-thread
  • ConcurrentHashMap est conçu pour la concurrence
  • il réduit la contention grâce à un verrouillage fin
  • il permet de meilleures performances en parallèle

🧾 En résumé

  • HashMap → simple, rapide, mais non sécurisé
  • ConcurrentHashMap → sécurisé et performant en multi-thread
  • synchronizedMap → fonctionne mais moins performant
  • en concurrence réelle → privilégier ConcurrentHashMap

Le choix de la structure de données impacte directement la performance et la stabilité d’une application concurrente.

Voir aussi