Maîtriser ConcurrentMap de Java : Maps Thread-Safe Expliquées

Interface Java ConcurrentMap

Apprenez comment ConcurrentMap de Java fournit des opérations de map thread-safe, ses méthodes principales et un exemple pratique avec ConcurrentHashMap.

L'interface ConcurrentMap étend java.util.Map et fournit une implémentation de map hautement concurrente et thread-safe. Elle garantit que plusieurs threads peuvent effectuer des opérations de lecture, écriture et mise à jour simultanément sans corrompre l'état interne de la map.

Puisque ConcurrentMap est une interface, vous ne pouvez pas l'instancier directement. L'implémentation la plus courante est java.util.concurrent.ConcurrentHashMap, qui offre des lectures sans verrou et un verrouillage à granularité fine pour les mises à jour.

---

Classes Implémentant ConcurrentMap

Bien que ConcurrentMap ne puisse pas être instanciée directement, vous pouvez créer une map concrète en utilisant l'une de ses implémentations. Le standard de facto est ConcurrentHashMap, mais des alternatives comme ConcurrentSkipListMap existent pour les besoins de map triée.

---

Utilisation de ConcurrentMap

Importez d'abord l'interface :

import java.util.concurrent.ConcurrentMap;

Puis créez une instance de ConcurrentHashMap :

ConcurrentMap<String, Integer> numbers = new ConcurrentHashMap<>();

Dans cet exemple, numbers est une map thread-safe où chaque clé String est associée à une valeur Integer.

Concepts clés :

• Clé – un identifiant unique qui mappe vers une valeur.
• Valeur – la donnée associée à une clé.

---

Méthodes Clés de ConcurrentMap

En plus de toutes les opérations standard de Map, ConcurrentMap introduit plusieurs méthodes atomiques, sans verrou :

• putIfAbsent(K key, V value) – Ajoute la paire clé/valeur seulement si la clé n'est pas déjà présente.
• compute(K key, BiFunction) – Met à jour atomiquement la valeur pour la clé spécifiée basée sur sa valeur courante.
• computeIfAbsent(K key, Function) – Génère une valeur pour une clé manquante en utilisant une fonction fournie.
• computeIfPresent(K key, BiFunction) – Met à jour la valeur d'une clé existante atomiquement.
• forEach(BiConsumer) – Effectue l'action donnée pour chaque entrée.
• merge(K key, V value, BiFunction) – Combine la nouvelle valeur avec la valeur existante en utilisant la fonction fournie.

Pour une référence approfondie, voir la documentation officielle Java.

---

Utilisation de ConcurrentHashMap avec ConcurrentMap

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;
public class Main {
    public static void main(String[] args) {
        // Créer une map thread-safe
        ConcurrentMap<String, Integer> numbers = new ConcurrentHashMap<>();
        // Insérer des éléments
        numbers.put("Two", 2);
        numbers.put("One", 1);
        numbers.put("Three", 3);
        System.out.println("ConcurrentMap: " + numbers);
        // Récupérer une valeur
        int value = numbers.get("One");
        System.out.println("Valeur Accédée: " + value);
        // Supprimer une paire clé/valeur
        int removed = numbers.remove("Two");
        System.out.println("Valeur Supprimée: " + removed);
    }
}

Sortie

ConcurrentMap: {One=1, Two=2, Three=3} Valeur Accédée: 1 Valeur Supprimée: 2

Pour une utilisation plus avancée, consultez la documentation ConcurrentHashMap.