Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

CountDownLatch in Java: costruttore, await e countDown

Usa un contatore monouso per dare il via o aspettare un numero fisso di segnali. Scopri i due overload di await, la gestione delle interruzioni e la visibilità delle scritture tra thread.

Versione: Java SE 21

Sintassi

Java SE 21 — java.util.concurrent.CountDownLatch
public CountDownLatch(int count)
public void await() throws InterruptedException
public boolean await(long timeout, TimeUnit unit) throws InterruptedException
public void countDown()

In Java SE 21, java.util.concurrent.CountDownLatch è un meccanismo di sincronizzazione monouso. Il costruttore CountDownLatch(int) imposta il numero di segnali, non di thread: un thread può segnalare più eventi. Con 0 il cancello parte aperto; un valore negativo causa IllegalArgumentException. CountDownLatch.countDown sottrae uno da un contatore positivo senza attendere altri segnali. Il passaggio a zero sblocca tutti i thread in attesa, senza stabilire l'ordine di ripresa. A zero, le successive chiamate a countDown() non hanno effetto. Il contatore non può essere reimpostato: per un altro ciclo serve una nuova istanza.

CountDownLatch.await ha due overload. await() restituisce void e, se il contatore è positivo, attende senza limiti di tempo. await(long timeout, TimeUnit unit) restituisce true se il contatore è o arriva a zero, oppure false se il tempo scade prima. Un timeout non positivo verifica lo stato senza attendere. Entrambi gli overload lanciano InterruptedException e azzerano lo stato di interruzione se è impostato all'ingresso o se il thread viene interrotto durante l'attesa. In assenza di interruzioni, a zero ritornano subito.

La coppia CountDownLatch.await/countDown garantisce la visibilità dei dati. Le azioni precedenti a un countDown() che riduce il contatore sono in relazione happens-before con le azioni di un altro thread dopo il ritorno riuscito da await() o dopo true dalla variante con timeout sulla stessa istanza. Un risultato false non offre questa garanzia. Il cancello non garantisce la mutua esclusione.

Usa un contatore per ogni condizione. start = 1 dà il via comune; done = 3 raccoglie tre segnali di completamento. Per due gruppi, imposta immediateReady = 2 e deferredReady = 4. Ogni partecipante segnala una volta di essere pronto nel proprio gruppo e il primo gruppo non può proseguire finché il coordinatore non apre il cancello separato releaseImmediate = 1. Quando entrambi i contatori di disponibilità arrivano a zero, sai senza Thread.sleep che sono arrivati almeno due segnali dal primo gruppo e almeno quattro dal secondo, ma non che i thread siano già bloccati. Con un segnale per partecipante, i totali di due e quattro sono garantiti solo se il numero di partecipanti per gruppo è fissato a due e quattro rispettivamente, indipendentemente dai contatori. Per coordinare l'occupazione di una risorsa, usa due contatori da 1: il primo conferma l'acquisizione, il secondo dà il via al rilascio.

Un segnale mancante può lasciare un thread in attesa indefinitamente. Se conti i tentativi conclusi, compresi quelli falliti, chiama countDown() in finally e segnala gli errori separatamente. Zero conferma l'arrivo dei segnali richiesti, non il successo del lavoro.

Esempi

import java.util.Arrays;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class LatchDemo {
    public static void main(String[] args) throws InterruptedException {
        int[] results = new int[3];
        int[] input = new int[1];
        CountDownLatch start = new CountDownLatch(1);
        CountDownLatch done = new CountDownLatch(3);

        for (int i = 0; i < results.length; i++) {
            int slot = i;
            new Thread(() -> {
                try {
                    start.await();
                    results[slot] = input[0] + slot;
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    done.countDown();
                }
            }).start();
        }

        System.out.println("Start open: " + start.await(0, TimeUnit.SECONDS));
        input[0] = 10;
        start.countDown();
        done.await();
        System.out.println("Results: " + Arrays.toString(results));
        done.countDown();
        System.out.println("Done open: " + done.await(0, TimeUnit.SECONDS));
    }
}

Risultato

Start open: false
Results: [10, 11, 12]
Done open: true

Solo `main` stampa. Prima verifica che il cancello sia chiuso, poi scrive `10` e apre `start`. Ogni thread scrive nella propria posizione dell'array. Dopo `done.await()`, queste scritture sono visibili a `main`; la chiamata aggiuntiva a `done.countDown()` non richiude il cancello.

Lezioni correlate

  • Java · Lezione 34 · Avanzato · Versione: 2
  • Java · Lezione 36 · Avanzato · Versione: 2
  • Java · Lezione 58 · Intermedio · Versione: 2

Fonti