Maîtriser Java ConcurrentHashMap : Opérations, Exemples et Bonnes Pratiques

Java ConcurrentHashMap

Explorez la classe Java ConcurrentHashMap, apprenez à la créer et la manipuler, et découvrez ses avantages clés avec des exemples de code pratiques.

La classe ConcurrentHashMap du framework de collections Java offre une implémentation de map thread-safe. Plusieurs threads peuvent lire et écrire simultanément sans corrompre l'intégrité de la map.

Elle implémente l'interface ConcurrentMap et fait partie de java.util.concurrent.

---

Création d'un ConcurrentHashMap

Importez d'abord la classe :

import java.util.concurrent.ConcurrentHashMap;

Puis instanciez-la. Vous pouvez spécifier une capacité initiale et un facteur de charge, ou compter sur les défauts.

// Capacité 8, facteur de charge 0.6
ConcurrentHashMap<Key, Value> numbers = new ConcurrentHashMap<>(8, 0.6f);

Paramètres

• capacity – le nombre initial de buckets (8 dans l'exemple).
• loadFactor – déclenche un redimensionnement quand la map atteint 60% de remplissage.

Le constructeur par défaut crée une map avec une capacité de 16 et un facteur de charge de 0.75 :

ConcurrentHashMap<Key, Value> numbers1 = new ConcurrentHashMap<>();

---

Création de ConcurrentHashMap depuis des Maps Existantes

Vous pouvez peupler un nouveau ConcurrentHashMap avec les entrées de n'importe quelle autre map.

import java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;
class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> evenNumbers = new HashMap<>();
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("HashMap: " + evenNumbers);
        ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(evenNumbers);
        numbers.put("Three", 3);
        System.out.println("ConcurrentHashMap: " + numbers);
    }
}

Sortie

HashMap: {Four=4, Two=2} ConcurrentHashMap: {Four=4, Two=2, Three=3}

---

Méthodes Clés de ConcurrentHashMap

Insertion d'Éléments

• put(K key, V value) – Ajoute ou remplace un mapping.
• putAll(Map<? extends K, ? extends V> m) – Insertion en masse.
• putIfAbsent(K key, V value) – Insère seulement si la clé est absente.

ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>();
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
evenNumbers.putIfAbsent("Six", 6);
System.out.println("Nombres pairs: " + evenNumbers);
ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.putAll(evenNumbers);
System.out.println("Nombres: " + numbers);

Sortie

Nombres pairs: {Six=6, Four=4, Two=2} Nombres: {Six=6, One=1, Four=4, Two=2}

Accès aux Éléments

Utilisez les vues de collection ou les méthodes de récupération clé/valeur.

• entrySet(), keySet(), values() – Retournent des collections d'entrées, clés ou valeurs.
• get(K key) – Récupère une valeur ou null si absente.
• getOrDefault(K key, V defaultValue) – Récupère une valeur ou une valeur par défaut fournie.

ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("Map: " + numbers);
System.out.println("Entrées: " + numbers.entrySet());
System.out.println("Clés: " + numbers.keySet());
System.out.println("Valeurs: " + numbers.values());
int val = numbers.get("Three");
System.out.println("get(\"Three\"): " + val);
int def = numbers.getOrDefault("Five", 5);
System.out.println("getOrDefault(\"Five\", 5): " + def);

Sortie

Map: {One=1, Two=2, Three=3} Entrées: [One=1, Two=2, Three=3] Clés: [One, Two, Three] Valeurs: [1, 2, 3] get("Three"): 3 getOrDefault("Five", 5): 5

Suppression d'Entrées

• remove(K key) – Supprime le mapping et retourne sa valeur.
• remove(K key, V value) – Supprime seulement si la valeur courante correspond ; retourne un booléen.

ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
int removed = numbers.remove("Two");
System.out.println("Valeur supprimée: " + removed);
boolean deleted = numbers.remove("Three", 3);
System.out.println("Entrée {Three=3} supprimée? " + deleted);
System.out.println("Map mise à jour: " + numbers);

Sortie

Valeur supprimée: 2 Entrée {Three=3} supprimée? true Map mise à jour: {One=1}

Opérations en Masse (Bulk Operations)

Ces méthodes exploitent le parallélisme pour traiter efficacement de grandes maps.

forEach()

Itère sur les entrées, optionnellement en parallèle, et applique un consumer.

numbers.forEach(4, (k, v) -> System.out.println("key: " + k + " value: " + v));
// Avec un transformateur:
numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", "));

Ici 4 est le seuil de parallélisme – quand la map a au moins 4 éléments, l'opération peut s'exécuter concurremment.

search()

Trouve une entrée satisfaisant un prédicat. Retourne la première correspondance.

String key = numbers.search(4, (k, v) -> v == 3 ? k : null);
System.out.println("Clé recherchée: " + key);

reduce()

Agrège les valeurs en utilisant un réducteur. Utile pour sommes, produits ou accumulations personnalisées.

int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2);
System.out.println("Somme des valeurs: " + sum);

ConcurrentHashMap vs HashMap

• Sécurité des threads – ConcurrentHashMap permet des modifications concurrentes sûres ; HashMap n'est pas thread-safe.
• Méthodes en masse – ConcurrentHashMap offre forEach, search et reduce pour le traitement parallèle.

Pourquoi Utiliser ConcurrentHashMap?

• Supporte la haute concurrence avec un blocage minimal.
• Divisée en interne en 16 segments, permettant jusqu'à 16 threads de modifier différents segments simultanément.
• Opérations comme putIfAbsent préviennent les écrasements accidentels.
• Synchronisation intégrée éliminant le besoin de verrous externes.