Was können Sie über Multithread-Sammlungen in Java…

Konkurrierende Sammlungen in Java bieten sichere Möglichkeiten, mit Daten aus mehreren Threads gleichzeitig zu arbeiten, wodurch Race Conditions und andere Synchronisationsprobleme vermieden werden.

Die wichtigsten Schnittstellen und Klassen umfassen:

ConcurrentMap: Erweitert Map und sorgt für atomare Operationen.
- ConcurrentHashMap: Hochleistungsimplementierung, die die gesamte Karte bei Änderungen nicht blockiert. Bietet Thread-Sicherheit ohne vollständiges Sperren.
CopyOnWriteArrayList und CopyOnWriteArraySet: Thread-sichere Sammlungen, die bei jeder Änderung eine Kopie des Basiselements erstellen. Gut geeignet für Sammlungen, die häufig gelesen und selten geändert werden. Lesen erfolgt ohne Sperre.
BlockingQueue: Schnittstelle für Warteschlangen, die Operationen mit Warten unterstützt, bis die Warteschlange leer oder voll ist. Wird zur Organisation der Interaktion zwischen Threads verwendet, z.B. im Producer-Consumer-Muster.
- ArrayBlockingQueue: Implementierung von BlockingQueue basierend auf Array mit fester Kapazität.
- LinkedBlockingQueue: Implementierung von BlockingQueue basierend auf verketteter Liste mit optionaler Kapazität.
- SynchronousQueue: Warteschlange mit null Kapazität. Jede Einfügeoperation wartet auf eine entsprechende Entnahmeoperation und umgekehrt.
ConcurrentLinkedQueue: Thread-sichere Implementierung von Queue basierend auf verketteter Liste. Unterstützt keine blockierenden Operationen.

Unterschiede zu synchronisierten Sammlungen (Collections.synchronizedList, Collections.synchronizedMap usw.):

Synchronisierte Sammlungen verwenden eine vollständige Sperre auf Objektebene, was bei hoher Konkurrenz die Leistung verringern kann.
Konkurrierende Sammlungen wie ConcurrentHashMap verwenden feinere Sperren oder andere Mechanismen für bessere Leistung.
Iteratoren synchronisierter Sammlungen können ConcurrentModificationException werfen, wenn die Sammlung während der Iteration durch einen anderen Thread modifiziert wird. Iteratoren konkurrierender Sammlungen sind in der Regel widerstandsfähiger gegen solche Änderungen.

Die Wahl einer bestimmten konkurrierenden Sammlung hängt vom Nutzungsszenario ab: Lese-/Schreibhäufigkeit, Notwendigkeit blockierender Operationen, Leistungsanforderungen usw.

Beispiel für die Verwendung von ConcurrentHashMap:

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentExample {

    private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    public void updateValue(String key, Integer value) {
        map.put(key, value); // Thread-sichere Operation
    }

    public Integer getValue(String key) {
        return map.get(key); // Thread-sichere Operation
    }

    public void incrementValue(String key) {
        // Atomare Operation: Wenn der Schlüssel nicht existiert, wird 1 eingefügt, sonst wird der Wert erhöht
        map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);
    }
}

Beispiel für die Verwendung von BlockingQueue:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

public class ProducerConsumer {

    private final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

    // Produzent
    public void produce(Integer item) throws InterruptedException {
        queue.put(item); // Blockiert, wenn die Warteschlange voll ist
        System.out.println("Produced: " + item);
    }

    // Konsument
    public Integer consume() throws InterruptedException {
        Integer item = queue.take(); // Blockiert, wenn die Warteschlange leer ist
        System.out.println("Consumed: " + item);
        return item;
    }
}

Was können Sie über Multithread-Sammlungen in Java erzählen?