Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Thread.interrupt — richiedere un’interruzione e ripristinare lo stato

Un’interruzione è un segnale, non un arresto forzato. Scopri quando `InterruptedException` indica che lo stato di interruzione è stato azzerato e come ripristinarlo.

Versione: Java SE 21

Sintassi

public void interrupt()

target.interrupt();
Thread.currentThread().interrupt();

In Java SE 21, Thread.interrupt è un metodo di istanza di java.lang.Thread senza argomenti e con tipo di ritorno void. La chiamata target.interrupt() invia il segnale al thread indicato da target, che può essere lo stesso thread chiamante. L’interruzione è cooperativa: un ciclo di calcolo può controllare lo stato e terminare il proprio lavoro. Interrompere un thread non ancora avviato o già terminato può non avere effetto. Un thread può sempre interrompere sé stesso; interrompere un altro thread può causare una SecurityException.

Di norma, interrupt() imposta lo stato di interruzione del thread destinatario. Quando Thread.sleep(long), Object.wait() o Thread.join() reagisce all’interruzione, l’operazione azzera lo stato e lancia InterruptedException nel thread che la esegue. Non tutte le operazioni bloccanti si comportano così: se l’I/O è bloccato su un InterruptibleChannel, il canale viene chiuso, lo stato viene impostato e viene lanciata ClosedByInterruptException. Un’operazione di selezione su un Selector ritorna con lo stato impostato.

Se non gestisci l’interruzione a questo livello, propaga InterruptedException quando la firma del metodo lo consente. Se non puoi propagare l’eccezione controllata, ripristina lo stato con Thread.currentThread().interrupt() e termina il lavoro interrotto, per esempio con return. Non ignorare l’eccezione e non riprovare incondizionatamente: un blocco catch vuoto può far perdere il segnale.

target.isInterrupted() legge lo stato del thread indicato senza modificarlo. Il metodo statico Thread.interrupted() legge e azzera solo lo stato del thread corrente. Usa isInterrupted() per controllare lo stato senza azzerarlo.

Esempi

public class InterruptDemo {
    public static void main(String[] args) {
        Thread current = Thread.currentThread();
        current.interrupt();
        System.out.println("Before sleep: " + current.isInterrupted());

        pause();

        System.out.println("After pause: " + current.isInterrupted());
        System.out.println("Read and clear: " + Thread.interrupted());
        System.out.println("After clear: " + current.isInterrupted());
    }

    private static void pause() {
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            System.out.println("In catch: " + Thread.currentThread().isInterrupted());
            Thread.currentThread().interrupt();
            return;
        }
    }
}

Risultato

Before sleep: true
In catch: false
After pause: true
Read and clear: true
After clear: false

Il thread principale interrompe sé stesso prima di `sleep`. Lo stato vale `false` in `catch` e `true` al ritorno da `pause` perché è stato ripristinato. `Thread.interrupted()` restituisce `true` e azzera lo stato, quindi l’ultima lettura dà `false`.

Lezioni correlate

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

Fonti