Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Thread.join — Attendere la terminazione di un thread

Usa `Thread.join` per attendere la terminazione di un thread. Distingui gli overload che confermano la terminazione e scopri quando puoi leggere il risultato.

Versione: Java SE 21

Sintassi

public final void join() throws InterruptedException
public final void join(long millis) throws InterruptedException
public final void join(long millis, int nanos) throws InterruptedException
public final boolean join(java.time.Duration duration) throws InterruptedException

Thread.join è un metodo di istanza di java.lang.Thread. Con worker.join(), il thread chiamante attende che worker termini. join non avvia né ferma il thread di lavoro. Chiama prima start(); join() senza argomenti non ha un limite di tempo.

join(long millis) accetta un limite in millisecondi, mentre join(long millis, int nanos) permette di aggiungere nanosecondi. Un valore negativo per millis o un valore di nanos fuori dall’intervallo da 0 a 999 999 causa IllegalArgumentException. Se tutti gli argomenti valgono zero, non c’è alcun limite di tempo. Entrambi gli overload restituiscono void: il ritorno da una chiamata con limite non conferma da solo la terminazione. Se il thread è stato avviato, verificare poi isAlive() == false conferma che a quel punto è terminato. Tutte e tre le varianti void ritornano subito per un thread non avviato.

join(java.time.Duration), disponibile da Java 19, restituisce true se il thread è terminato e false altrimenti. Con una durata pari a zero o negativa, controlla senza attendere. Per un thread non avviato, questo overload lancia IllegalThreadStateException.

Le azioni del thread di lavoro precedono, secondo la relazione happens-before, il rilevamento della sua terminazione da parte di un altro thread. Dopo aver confermato la terminazione, il chiamante può leggere il risultato anche da un campo non volatile, purché non ci siano scritture in conflitto. Se più thread contribuiscono a un risultato, attendili tutti con join prima di leggerlo. join non elimina le condizioni di competizione tra i thread e non prova che il compito sia stato eseguito senza errori.

Se join lancia InterruptedException, azzera lo stato di interruzione del thread chiamante, non quello del thread di lavoro. Propaga l’eccezione oppure, se la intercetti per uscire dall’operazione corrente, ripristina lo stato con Thread.currentThread().interrupt(). Non interpretare l’interruzione come una conferma della terminazione.

Esempi

import java.time.Duration;
import java.util.concurrent.CountDownLatch;

public class JoinDemo {
    static final class Result {
        int value;
    }

    public static void main(String[] args) throws InterruptedException {
        Result result = new Result();
        CountDownLatch release = new CountDownLatch(1);
        Thread worker = new Thread(() -> {
            try {
                release.await();
                result.value = 42;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        Duration timeout = Duration.ofMillis(10);
        worker.start();

        boolean before;
        try {
            before = worker.join(timeout);
        } finally {
            release.countDown();
        }
        worker.join();
        boolean after = worker.join(timeout);

        System.out.println("before = " + before);
        System.out.println("after = " + after);
        System.out.println("value = " + result.value);
    }
}

Risultato

before = false
after = true
value = 42

Il contatore di sincronizzazione impedisce al thread di lavoro di terminare durante il primo tentativo con timeout, che restituisce `false`. Quando il contatore viene portato a zero, `join()` conferma la terminazione: il secondo tentativo con timeout restituisce `true` e `main` legge `42`.

Lezioni correlate

  • Java · Lezione 49 · Intermedio · Versione: 2
  • Java · Lezione 52 · Intermedio · Versione: 2
  • Java · Lezione 53 · Intermedio · Versione: 2
  • Java · Lezione 58 · Intermedio · Versione: 2

Fonti