CKTIS / Java
ConcurrentHashMap: Zähler atomar initialisieren und Einträge durchlaufen
Mit `computeIfAbsent` wird ein `LongAdder` für einen fehlenden Schlüssel atomar angelegt. Mit `forEach` lassen sich die Zählerstände ohne Annahmen über die Reihenfolge auslesen.
Version: Java SE 21
Syntax
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)In Java SE 21 liefert computeIfAbsent(key, factory) von java.util.concurrent.ConcurrentHashMap atomar den vorhandenen Wert, ohne die Funktion aufzurufen. Fehlt der Schlüssel, ruft die Methode die Funktion pro Aufruf einmal auf, speichert ein Ergebnis ungleich null und gibt es zurück. Die Standardimplementierung von Map.computeIfAbsent garantiert weder Synchronisierung noch Atomarität. Verweist eine Map-Referenz auf eine ConcurrentHashMap, wird weiterhin die überschreibende Methode der Klasse aufgerufen.
Die Map erlaubt weder Schlüssel noch Werte mit null. Ein Schlüssel oder eine Funktion mit null löst NullPointerException aus; liefert die Funktion null, wird null zurückgegeben, ohne einen Eintrag anzulegen. RuntimeException und Error aus der Funktion werden weitergegeben, ohne einen Eintrag anzulegen. Halte die Funktion kurz und ändere darin nicht dieselbe Map: Andere Aktualisierungen können warten müssen, und eine erkannte rekursive Aktualisierung, die sonst nie enden würde, löst IllegalStateException aus.
In counts.computeIfAbsent(word, k -> new LongAdder()).increment() beginnt der Zähler aus java.util.concurrent.atomic bei null. Das threadsichere increment() folgt auf die Map-Operation und gehört nicht zu derselben atomaren Operation. Entfernt oder ersetzt ein anderer Thread den Eintrag, kann ein Zähler erhöht werden, der nicht mehr in der Map steht. Ohne gleichzeitige Änderungen am Zähler liefert sum() den exakten Wert, aber keine atomare Momentaufnahme.
forEach(action) übergibt Schlüssel und Wert sequenziell an die Aktion, ohne Schwellenwert. forEach(threshold, action) kann je nach geschätzter Map-Größe ForkJoinPool.commonPool() nutzen: Long.MAX_VALUE schaltet die parallele Ausführung ab, 1 begünstigt maximale Parallelität. Bei paralleler Ausführung muss die Aktion sicher auf gemeinsam genutzten Zustand zugreifen. forEach(threshold, transformer, action) übergibt nur Transformationsergebnisse ungleich null. Keine Überladung garantiert eine Reihenfolge oder bei laufenden Änderungen eine atomare Momentaufnahme der gesamten Map.
Beispiele
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));
}
}Ergebnis
apple=2 pear=2 plum=1
Nach beiden `join()`-Aufrufen ändern sich die Zähler nicht mehr. `Long.MAX_VALUE` sorgt für sequenzielle Schreibzugriffe auf die `TreeMap`, die die Ausgabe nach Schlüsseln sortiert.
Zugehörige Lektionen
- Java · Lektion 24 · Fortgeschritten · Version: 2