Co możesz powiedzieć o kolekcjach wielowątkowych w…

Kolekcje współbieżne w Javie zapewniają bezpieczne sposoby pracy z danymi z wielu wątków jednocześnie, zapobiegając warunkom wyścigu i innym problemom synchronizacji.

Główne interfejsy i klasy obejmują:

ConcurrentMap: Rozszerza Map, zapewniając operacje atomowe.
- ConcurrentHashMap: Wysokowydajna implementacja, która nie blokuje całej mapy podczas modyfikacji. Zapewnia bezpieczeństwo wątków bez pełnego blokowania.
CopyOnWriteArrayList i CopyOnWriteArraySet: Kolekcje bezpieczne dla wątków, które tworzą kopię podstawowej tablicy przy każdej modyfikacji. Dobrze nadają się do kolekcji często czytanych i rzadko modyfikowanych. Odczyt odbywa się bez blokady.
BlockingQueue: Interfejs kolejki obsługujący operacje oczekiwania, aż kolejka stanie się pusta lub pełna. Używany do organizacji interakcji między wątkami, np. w wzorcu producent-konsument.
- ArrayBlockingQueue: Implementacja BlockingQueue oparta na tablicy o stałej pojemności.
- LinkedBlockingQueue: Implementacja BlockingQueue oparta na liście powiązanej z opcjonalną pojemnością.
- SynchronousQueue: Kolejka o zerowej pojemności. Każda operacja wstawiania oczekuje na odpowiadającą operację pobierania i odwrotnie.
ConcurrentLinkedQueue: Bezpieczna dla wątków implementacja Queue oparta na liście powiązanej. Nie obsługuje operacji blokujących.

Różnice w stosunku do synchronizowanych kolekcji (Collections.synchronizedList, Collections.synchronizedMap itd.):

Synchronizowane kolekcje używają pełnego blokowania na poziomie obiektu, co może obniżać wydajność przy dużej konkurencji.
Kolekcje współbieżne, takie jak ConcurrentHashMap, używają bardziej granularnego blokowania lub innych mechanizmów dla lepszej wydajności.
Iteratory synchronizowanych kolekcji mogą rzucać ConcurrentModificationException podczas modyfikacji kolekcji w trakcie iteracji z innego wątku. Iteratory kolekcji współbieżnych są zwykle bardziej odporne na takie zmiany.

Wybór konkretnej kolekcji współbieżnej zależy od scenariusza użycia: częstotliwości odczytów/zapisów, konieczności operacji blokujących, wymagań dotyczących wydajności itp.

Przykład użycia 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); // Bezpieczna operacja dla wątków
    }

    public Integer getValue(String key) {
        return map.get(key); // Bezpieczna operacja dla wątków
    }

    public void incrementValue(String key) {
        // Operacja atomowa: jeśli klucz nie istnieje, wstawi 1, w przeciwnym razie zwiększy istniejącą wartość
        map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);
    }
}

Przykład użycia BlockingQueue:

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

public class ProducerConsumer {

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

    // Producent
    public void produce(Integer item) throws InterruptedException {
        queue.put(item); // Zablokuje się, jeśli kolejka jest pełna
        System.out.println("Produced: " + item);
    }

    // Konsument
    public Integer consume() throws InterruptedException {
        Integer item = queue.take(); // Zablokuje się, jeśli kolejka jest pusta
        System.out.println("Consumed: " + item);
        return item;
    }
}

Co możesz powiedzieć o kolekcjach wielowątkowych w Java?