Cosa puoi raccontare sulle collezioni multithread in…

Le collezioni concorrenti in Java offrono modi sicuri per lavorare con dati provenienti da più thread contemporaneamente, prevenendo condizioni di gara e altri problemi di sincronizzazione.

Le principali interfacce e classi includono:

ConcurrentMap: Estende Map, garantendo operazioni atomiche.
- ConcurrentHashMap: Implementazione ad alte prestazioni che non blocca l'intera mappa durante le modifiche. Garantisce la sicurezza dei thread senza blocco completo.
CopyOnWriteArrayList e CopyOnWriteArraySet: Collezioni thread-safe che creano una copia dell'array di base ad ogni modifica. Ideali per collezioni frequentemente lette e raramente modificate. La lettura avviene senza blocco.
BlockingQueue: Interfaccia di coda che supporta operazioni di attesa fino a che la coda non sia vuota o piena. Usata per organizzare l'interazione tra thread, ad esempio nel pattern producer-consumer.
- ArrayBlockingQueue: Implementazione di BlockingQueue basata su array con capacità fissa.
- LinkedBlockingQueue: Implementazione di BlockingQueue basata su lista collegata con capacità opzionale.
- SynchronousQueue: Coda a capacità zero. Ogni operazione di inserimento aspetta una corrispondente operazione di estrazione e viceversa.
ConcurrentLinkedQueue: Implementazione thread-safe di Queue basata su lista collegata. Non supporta operazioni di blocco.

Differenze rispetto alle collezioni sincronizzate (Collections.synchronizedList, Collections.synchronizedMap, ecc.):

Le collezioni sincronizzate usano un blocco completo a livello di oggetto, il che può ridurre le prestazioni in alta concorrenza.
Le collezioni concorrenti, come ConcurrentHashMap, usano blocchi più granulari o altri meccanismi per ottenere migliori prestazioni.
Gli iterator delle collezioni sincronizzate possono lanciare ConcurrentModificationException se la collezione viene modificata durante l'iterazione da un altro thread. Gli iterator delle collezioni concorrenti sono generalmente più resilienti a tali modifiche.

La scelta di una collezione concorrente dipende dallo scenario di utilizzo: frequenza di lettura/scrittura, necessità di operazioni di blocco, requisiti di prestazioni, ecc.

Esempio di utilizzo di 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); // Operazione thread-safe
    }

    public Integer getValue(String key) {
        return map.get(key); // Operazione thread-safe
    }

    public void incrementValue(String key) {
        // Operazione atomica: se la chiave non esiste, inserisce 1, altrimenti incrementa il valore esistente
        map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);
    }
}

Esempio di utilizzo di BlockingQueue:

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

public class ProducerConsumer {

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

    // Produttore
    public void produce(Integer item) throws InterruptedException {
        queue.put(item); // Si blocca se la coda è piena
        System.out.println("Produced: " + item);
    }

    // Consumatore
    public Integer consume() throws InterruptedException {
        Integer item = queue.take(); // Si blocca se la coda è vuota
        System.out.println("Consumed: " + item);
        return item;
    }
}

Cosa puoi raccontare sulle collezioni multithread in Java?