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 InterruptedExceptionThread.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