CKTIS / Java
ConcurrentHashMap : initialiser des compteurs atomiquement et parcourir les entrées
Utilisez `computeIfAbsent` pour initialiser atomiquement un `LongAdder` pour une clé absente, puis `forEach` pour lire les compteurs sans dépendre de l’ordre de parcours.
Version : Java SE 21
Syntaxe
V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
void forEach(BiConsumer<? super K, ? super V> action)
void forEach(long parallelismThreshold, BiConsumer<? super K, ? super V> action)
<U> void forEach(long parallelismThreshold, BiFunction<? super K, ? super V, ? extends U> transformer, Consumer<? super U> action)En Java SE 21, computeIfAbsent(key, factory) de java.util.concurrent.ConcurrentHashMap renvoie atomiquement la valeur existante sans appeler la fonction. Si la clé est absente, la méthode appelle la fonction une fois pour cet appel, enregistre le résultat s’il n’est pas null, puis le renvoie. L’implémentation par défaut de Map.computeIfAbsent ne garantit ni synchronisation ni atomicité. Une référence de type Map vers une ConcurrentHashMap appelle toujours la redéfinition de la classe.
La table n’accepte ni clé ni valeur null. Une clé ou une fonction null déclenche une NullPointerException ; un résultat null est renvoyé sans créer d’entrée. Une RuntimeException ou une Error issue de la fonction se propage sans créer d’entrée. La fonction doit rester courte et ne pas modifier cette même table : d’autres mises à jour peuvent attendre, et une mise à jour récursive détectée qui ne pourrait pas se terminer déclenche une IllegalStateException.
Dans counts.computeIfAbsent(word, k -> new LongAdder()).increment(), le compteur de java.util.concurrent.atomic démarre à zéro. L’appel à increment(), sûr en concurrence, suit l’opération sur la table sans faire partie de la même opération atomique. Si un autre thread supprime ou remplace l’entrée, l’incrément peut toucher un compteur qui ne figure plus dans la table. sum() est exact si le compteur n’est pas modifié simultanément, mais ne constitue pas un instantané atomique.
forEach(action) transmet la clé et la valeur à l’action de façon séquentielle, sans seuil. forEach(threshold, action) peut utiliser ForkJoinPool.commonPool() selon la taille estimée de la table : Long.MAX_VALUE désactive l’exécution parallèle et 1 favorise le parallélisme maximal. Une action parallèle doit accéder à l’état partagé de façon sûre. forEach(threshold, transformer, action) transmet uniquement les résultats de transformation non null. Aucune surcharge ne garantit un ordre de parcours ni un instantané atomique de l’ensemble de la table pendant les mises à jour.
Exemples
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.LongAdder;
public class WordCounts {
private static void count(ConcurrentHashMap<String, LongAdder> counts,
String... words) {
for (String word : words) {
counts.computeIfAbsent(word, k -> new LongAdder()).increment();
}
}
public static void main(String[] args) throws InterruptedException {
var counts = new ConcurrentHashMap<String, LongAdder>();
var first = new Thread(() -> count(counts, "pear", "apple", "pear"));
var second = new Thread(() -> count(counts, "apple", "plum"));
first.start();
second.start();
first.join();
second.join();
var sorted = new TreeMap<String, Long>();
counts.forEach(Long.MAX_VALUE, (word, counter) -> sorted.put(word, counter.sum()));
sorted.forEach((word, total) -> System.out.println(word + "=" + total));
}
}Résultat
apple=2 pear=2 plum=1
Après les deux appels à `join()`, les compteurs ne changent plus. `Long.MAX_VALUE` assure des écritures séquentielles dans la `TreeMap`, qui trie la sortie par clé.
Leçons associées
- Java · Leçon 24 · Avancé · Version : 2