Java ConcurrentHashMap meistern: Operationen, Beispiele und Best Practices

Java ConcurrentHashMap

Erkunden Sie die Java ConcurrentHashMap-Klasse, lernen Sie Erstellung und Manipulation, und entdecken Sie ihre Schlüsselvorteile mit praktischen Code-Beispielen.

Die ConcurrentHashMap-Klasse aus dem Java Collections Framework bietet eine thread-sichere Map-Implementierung. Mehrere Threads können gleichzeitig lesen und schreiben, ohne die Integrität der Map zu gefährden.

Sie implementiert das ConcurrentMap-Interface und ist Teil von java.util.concurrent.

---

ConcurrentHashMap erstellen

Zuerst die Klasse importieren:

import java.util.concurrent.ConcurrentHashMap;

Dann instanziieren. Sie können initiale Kapazität und Load Factor angeben, oder Defaults nutzen.

// Kapazität 8, Load Factor 0.6 ConcurrentHashMap<Key, Value> numbers = new ConcurrentHashMap<>(8, 0.6f);

Parameter

• capacity – initiale Bucket-Anzahl (8 im Beispiel).
• loadFactor – triggert Resize bei 60% Füllung.

Default-Konstruktor erstellt Map mit Kapazität 16 und Load Factor 0.75:

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

---

ConcurrentHashMap aus existierenden Maps erstellen

Sie können eine neue ConcurrentHashMap mit Einträgen jeder anderen Map befüllen.

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); } }

Ausgabe

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

---

Wichtige Methoden von ConcurrentHashMap

Elemente einfügen

• put(K key, V value) – Fügt Mapping hinzu oder ersetzt.
• putAll(Map<? extends K, ? extends V> m) – Bulk-Einfügung.
• putIfAbsent(K key, V value) – Fügt nur ein falls Key abwesend.

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

Ausgabe

Even numbers: {Six=6, Four=4, Two=2} Numbers: {Six=6, One=1, Four=4, Two=2}

Elemente abrufen

View-Collections oder Key/Value-Retrieval-Methoden nutzen.

• entrySet(), keySet(), values() – Liefern Collections von Einträgen, Keys oder Values.
• get(K key) – Ruft Wert ab oder null falls abwesend.
• getOrDefault(K key, V defaultValue) – Ruft Wert oder bereitgestellten Default ab.

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("Entries: " + numbers.entrySet()); System.out.println("Keys: " + numbers.keySet()); System.out.println("Values: " + 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);

Ausgabe

Map: {One=1, Two=2, Three=3} Entries: [One=1, Two=2, Three=3] Keys: [One, Two, Three] Values: [1, 2, 3] get("Three"): 3 getOrDefault("Five", 5): 5

Einträge entfernen

• remove(K key) – Löscht Mapping und gibt dessen Wert zurück.
• remove(K key, V value) – Löscht nur falls aktueller Wert matcht; gibt boolean zurück.

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("Removed value: " + removed); boolean deleted = numbers.remove("Three", 3); System.out.println("Entry {Three=3} removed? " + deleted); System.out.println("Updated map: " + numbers);

Ausgabe

Removed value: 2 Entry {Three=3} removed? true Updated map: {One=1}

Bulk-Operationen

Diese Methoden nutzen Parallelismus für effiziente Verarbeitung großer Maps.

forEach()

Iteriert über Einträge, optional parallel, und wendet Consumer an.

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

Hier ist 4 der Parallelitätsschwellenwert – bei mindestens 4 Elementen kann die Operation parallel laufen.

search()

Findet Eintrag, der Prädikat erfüllt. Gibt ersten Match zurück.

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

reduce()

Aggregiert Werte mittels Reducer. Nützlich für Summen, Produkte, oder custom Akkumulation.

int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2); System.out.println("Sum of values: " + sum);

ConcurrentHashMap vs. HashMap

• Thread-Sicherheit – ConcurrentHashMap erlaubt sichere konkurrierende Modifikationen; HashMap ist nicht thread-sicher.
• Bulk-Methoden – ConcurrentHashMap bietet forEach, search und reduce für parallele Verarbeitung.

Warum ConcurrentHashMap verwenden?

• Unterstützt hohe Nebenläufigkeit mit minimalem Blocking.
• Intern in 16 Segmente unterteilt, ermöglicht bis zu 16 Threads simultane Modifikation verschiedener Segmente.
• Operationen wie putIfAbsent verhindern versehentliche Überschreibungen.
• Eingebaute Synchronisation eliminiert Notwendigkeit externer Locks.