ConcurrentHashMap: Threadsicherheit und Flexibilität in Java

Die Klasse ConcurrentHashMap gehört zu den Concurrency Collection Classes in Java und bietet eine effektive Lösung zur Handhabung von Mehrfachzugriffen in einer multithreaded Umgebung. Sie basiert auf einer Hash-Tabellen-Implementierung, die gleichzeitige Lese- und Schreiboperationen unterstützt, ohne die Gefahr einer ConcurrentModificationException. Diese Flexibilität ist entscheidend für die Entwicklung moderner Anwendungen, die hohe Leistungsanforderungen haben.

Was ist eine ConcurrentHashMap?

Ein häufiges Problem in Java tritt auf, wenn man eine Sammlung während der Iteration modifiziert. Dies führt zu einer ConcurrentModificationException. Um diese Herausforderung zu bewältigen, wurden ab Java 1.5 Concurrent-Klassen im Paket java.util.concurrent eingeführt. Die ConcurrentHashMap erlaubt es, die Map während der Iteration zu modifizieren und garantiert, dass die Operationen threadsicher sind. Es ist wichtig zu beachten, dass ConcurrentHashMap keine null-Werte für Schlüssel und Werte zulässt. Dadurch wird sichergestellt, dass die Integrität der Daten während der gesamten Laufzeit gewahrt bleibt.

Beispiel einer ConcurrentHashMap in Java

Die ConcurrentHashMap ist ähnlich wie die HashMap, jedoch mit dem entscheidenden Vorteil der Thread-Sicherheit und der Möglichkeit zur Modifikation während der Iteration. Diese Eigenschaften machen sie zu einem idealen Kandidaten für die Speicherung von Daten in Anwendungen, die hohe Anforderungen an die Parallelität stellen.

Hier ist ein einfaches Beispiel zur Veranschaulichung:

 
package com.journaldev.util;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {

    public static void main(String[] args) {
        // ConcurrentHashMap
        Map<String, String> myMap = new ConcurrentHashMap<String, String>();
        myMap.put("1", "1");
        myMap.put("2", "1");
        myMap.put("3", "1");
        myMap.put("4", "1");
        myMap.put("5", "1");
        myMap.put("6", "1");
        
        System.out.println("ConcurrentHashMap vor Iterator: " + myMap);
        Iterator it = myMap.keySet().iterator();

        while (it.hasNext()) {
            String key = it.next();
            if (key.equals("3")) myMap.put(key + "new", "new3");
        }
        System.out.println("ConcurrentHashMap nach Iterator: " + myMap);

        // HashMap
        myMap = new HashMap<String, String>();
        myMap.put("1", "1");
        myMap.put("2", "1");
        myMap.put("3", "1");
        myMap.put("4", "1");
        myMap.put("5", "1");
        myMap.put("6", "1");
        
        System.out.println("HashMap vor Iterator: " + myMap);
        Iterator it1 = myMap.keySet().iterator();

        while (it1.hasNext()) {
            String key = it1.next();
            if (key.equals("3")) myMap.put(key + "new", "new3");
        }
        System.out.println("HashMap nach Iterator: " + myMap);
    }
}

Ausgaben und Fehleranalyse

Die Ausgabe des obigen Codes zeigt, dass die ConcurrentHashMap erfolgreich einen neuen Eintrag während der Iteration hinzufügt, während die HashMap eine ConcurrentModificationException wirft.

Ausgabe:

 
ConcurrentHashMap vor Iterator: {1=1, 5=1, 6=1, 3=1, 4=1, 2=1}
ConcurrentHashMap nach Iterator: {1=1, 3new=new3, 5=1, 6=1, 3=1, 4=1, 2=1}
HashMap vor Iterator: {3=1, 2=1, 1=1, 6=1, 5=1, 4=1}
Exception in thread "main" java.util.ConcurrentModificationException

Die ConcurrentModificationException tritt auf, weil der Iterator auf die Strukturänderung der HashMap reagiert, die während der Iteration erfolgt ist. Diese Ausnahme zeigt, wie wichtig es ist, die Funktionsweise von Sammlungen in Java zu verstehen.

Umgang mit Modifikationen in der Iteration

Wenn wir den Code so ändern, dass wir beim Einfügen eines neuen Eintrags aus der Iteration ausbrechen, vermeiden wir die Ausnahme:

 
if (key.equals("3")) {
    myMap.put(key + "new", "new3");
    break;  // Brechen Sie die Schleife ab
}

Fazit

Die ConcurrentHashMap ist eine leistungsstarke und flexible Lösung für multithreaded Umgebungen in Java. Sie ermöglicht Modifikationen während der Iteration, ohne dass es zu Ausnahmen kommt, was sie ideal für Anwendungen macht, die eine hohe Leistung und Sicherheit benötigen. Außerdem ist es erwähnenswert, dass die Verwendung von Generics bei der Erstellung von Sammlungsobjekten in Java nicht nur die Typprüfung zur Compile-Zeit verbessert, sondern auch zur Vermeidung von ClassCastException zur Laufzeit beiträgt. Diese Vorteile machen die ConcurrentHashMap zu einem unverzichtbaren Werkzeug für Entwickler.