CKTIS / Java
ConcurrentHashMap: get, put und atomares merge
Mit `get` liest du einen Wert, mit `put` schreibst du ihn bedingungslos, und mit `merge` aktualisierst du einen einzelnen Schlüssel atomar, etwa bei einem gemeinsamen Zähler.
Version: Java SE 21
Syntax
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;
// Instance methods of ConcurrentHashMap<K, V>
public V get(Object key)
public V put(K key, V value)
public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)In Java SE 21 liest ConcurrentHashMap.get (get(Object key)) einen Wert, ohne die Map zu ändern. Fehlt der Schlüssel, liefert die Methode null. ConcurrentHashMap.put fügt einen Wert ein oder ersetzt ihn und liefert den vorherigen Wert oder null, wenn es noch keinen Eintrag gab.
Fehlt der Schlüssel, fügt ConcurrentHashMap.merge den übergebenen Wert ein, ohne die Funktion aufzurufen. Ist er vorhanden, erhält die Funktion zuerst den bisherigen und dann den übergebenen Wert. merge speichert und liefert das Ergebnis. Liefert die Funktion null, entfernt merge den Eintrag und liefert null.
Die Map speichert weder null als Schlüssel noch als Wert. Ein null-Schlüssel bei diesen Methoden, ein null-Wert für put oder merge oder eine null-Funktion für merge führt zu einer NullPointerException. Wirft die Funktion eine RuntimeException oder einen Error, gibt merge diese weiter und lässt den Eintrag unverändert. Halte die Funktion kurz: Manche Aktualisierungen müssen möglicherweise warten, bis sie fertig ist. Die Funktion darf diese Map während der Berechnung nicht verändern. Erkennt merge den Versuch einer rekursiven Aktualisierung dieser Map, die andernfalls nie abgeschlossen würde, wirft es eine IllegalStateException.
Ein einzelner merge-Aufruf liest und aktualisiert den Eintrag zu einem Schlüssel atomar. Bei getrennten Aufrufen von get und put kann eine Erhöhung verloren gehen, wenn zwei Threads denselben Wert lesen und dasselbe Ergebnis schreiben. Diese Garantie gilt für ConcurrentHashMap, nicht für die Standardimplementierung von Map.merge. Sie bietet keine Transaktion über mehrere Schlüssel hinweg.
Beispiele
import java.util.concurrent.ConcurrentHashMap;
public class Main {
public static void main(String[] args) throws InterruptedException {
var counts = new ConcurrentHashMap<String, Integer>();
String key = "hits";
System.out.println(counts.get(key));
System.out.println(counts.merge(key, 1, Integer::sum));
System.out.println(counts.put(key, 10));
Runnable increment = () -> {
for (int i = 0; i < 1_000; i++) {
counts.merge(key, 1, Integer::sum);
}
};
Thread first = new Thread(increment);
Thread second = new Thread(increment);
first.start();
second.start();
first.join();
second.join();
System.out.println(counts.get(key));
System.out.println(counts.merge(key, 1, (oldValue, addedValue) -> null));
System.out.println(counts.get(key));
}
}Ergebnis
null 1 1 2010 null null
Der erste Lesezugriff liefert `null`. Der erste `merge`-Aufruf fügt `1` ein und liefert `1`; `put` speichert `10` und liefert die bisherige `1`. Beide Threads addieren je 1000. `join()` wartet auf ihr Ende, bevor `2010` gelesen wird. Der letzte `merge`-Aufruf entfernt den Eintrag. Deshalb liefern dieser Aufruf und der nächste Lesezugriff jeweils `null`.
Zugehörige Lektionen
- Java · Lektion 56 · Mittlere Stufe · Version: 2