Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Thread: avviare, attendere la terminazione e interrompere

Crea thread di piattaforma da attività Runnable, avviali una sola volta, leggine i risultati dopo join() e gestisci l’annullamento cooperativo senza perdere lo stato di interruzione.

Versione: Java SE 21

Sintassi

new Thread(task);             // task: Runnable
new Thread(task, name);       // name: String
worker.start();               // void
worker.join();                // void; throws InterruptedException
worker.join(millis);          // long; same return and checked exception
worker.join(millis, nanos);   // long, int; same return and checked exception
worker.join(duration);        // java.time.Duration; boolean; throws InterruptedException
Thread.currentThread();       // static; returns Thread
worker.getName();             // returns String
worker.interrupt();           // request interruption of worker
Thread.currentThread().interrupt(); // set the calling thread's interrupt status

In Java SE 21 entrambi i costruttori di java.lang.Thread creano un thread di piattaforma non ancora avviato, non un thread virtuale. Thread(Runnable) genera un nome; Thread(Runnable,String) usa il nome fornito. Il metodo statico Thread.currentThread() restituisce il thread che esegue la chiamata. Il metodo di istanza getName() ne restituisce il nome, un’etichetta e non un identificatore univoco.

worker.start() pianifica l’esecuzione dell’attività sul nuovo thread. Chiamare direttamente worker.run() esegue l’attività sul thread chiamante. Una seconda chiamata a start() lancia IllegalThreadStateException, anche dopo la terminazione. La relazione happens-before rende le azioni precedenti a start() visibili al thread avviato. L’ordine di avvio non determina quello di esecuzione.

worker.join() fa attendere il chiamante fino alla terminazione del thread avviato; se non è stato avviato, ritorna subito. Dopo il ritorno normale di join() su un thread avviato, le scritture di quel thread sono visibili al chiamante. Attendi tutti i produttori prima di leggere i risultati: questo non risolve le corse sui dati tra loro né dimostra che le attività siano riuscite. join(long) e join(long,int) possono ritornare alla scadenza del tempo; con tutti gli argomenti a zero l’attesa non ha limite. join(Duration) indica se il thread è terminato e lancia IllegalThreadStateException se non è stato avviato.

worker.interrupt() segnala un’interruzione al worker, ma non lo arresta forzatamente. Quando join() o await() lancia InterruptedException, lo stato di interruzione del thread chiamante viene azzerato. Propaga l’eccezione se puoi; altrimenti libera le risorse, ripristina lo stato con Thread.currentThread().interrupt() e termina il percorso di annullamento senza segnalare un successo. isInterrupted() legge lo stato senza azzerarlo; il metodo statico Thread.interrupted() legge e azzera quello del thread corrente. Non fare affidamento sull’interruzione di un thread non in vita. In Java SE 21 un gestore della sicurezza può vietare l’interruzione di un altro thread.

Esempi

import java.util.concurrent.CountDownLatch;

public class ThreadMethodsDemo {
    public static void main(String[] args) throws InterruptedException {
        var gate = new CountDownLatch(1);
        var observations = new String[2];

        Thread compute = new Thread(() -> observations[0] = "sum=" + (20 + 22));
        Thread cancellable = new Thread(() -> {
            Thread self = Thread.currentThread();
            try {
                gate.await();
            } catch (InterruptedException e) {
                self.interrupt();
                observations[1] = self.getName() + ": cancelled; interrupted="
                        + self.isInterrupted();
                return;
            }
        }, "cancellable");

        compute.start();
        cancellable.start();
        cancellable.interrupt();
        compute.join();
        cancellable.join();

        System.out.println(observations[0]);
        System.out.println(observations[1]);
    }
}

Risultato

sum=42
cancellable: cancelled; interrupted=true

Il primo thread registra una somma; il thread con nome registra l’annullamento. Il latch resta chiuso: `await()` reagisce all’interruzione sia prima sia durante l’attesa. Solo `main` stampa, dopo entrambi i `join()`, quindi l’ordine delle righe non dipende dalla pianificazione.

Lezioni correlate

  • Java · Lezione 25 · Avanzato · Versione: 2
  • Java · Lezione 28 · Avanzato · Versione: 2
  • Java · Lezione 30 · Avanzato · Versione: 2
  • Java · Lezione 33 · Avanzato · Versione: 2
  • Java · Lezione 34 · Avanzato · Versione: 2
  • Java · Lezione 35 · Avanzato · Versione: 2
  • Java · Lezione 36 · Avanzato · Versione: 2
  • Java · Lezione 37 · Avanzato · Versione: 2
  • Java · Lezione 38 · Avanzato · Versione: 2

Fonti