CKTIS / Java
Thread.interrupt — pedir uma interrupção e repor o estado
Uma interrupção é um sinal, não uma paragem forçada. Aprende quando `InterruptedException` indica que o estado de interrupção foi limpo e como o repor.
Versão: Java SE 21
Sintaxe
public void interrupt()
target.interrupt();
Thread.currentThread().interrupt();Em Java SE 21, Thread.interrupt é um método de instância de java.lang.Thread sem argumentos e com tipo de retorno void. A chamada target.interrupt() envia o sinal à thread indicada por target, que pode ser a própria thread que faz a chamada. A interrupção é cooperativa: um ciclo de cálculo pode consultar o estado e terminar o seu próprio trabalho. Interromper uma thread que ainda não arrancou ou que já terminou pode não ter efeito. Uma thread pode sempre interromper-se a si própria; interromper outra thread pode lançar uma SecurityException.
Normalmente, interrupt() ativa o estado de interrupção da thread de destino. Quando Thread.sleep(long), Object.wait() ou Thread.join() reage à interrupção, a operação limpa o estado e lança InterruptedException na thread que a executa. Nem todas as operações bloqueantes se comportam assim: se houver E/S bloqueada num InterruptibleChannel, o canal é fechado, o estado é ativado e é lançada ClosedByInterruptException. Uma operação de seleção num Selector retorna com o estado ativo.
Se não tratares a interrupção a este nível, propaga InterruptedException quando a assinatura do método o permitir. Se não puderes propagar a exceção verificada, repõe o estado com Thread.currentThread().interrupt() e termina o trabalho interrompido, por exemplo com return. Não ignores a exceção nem repitas a operação incondicionalmente: um bloco catch vazio pode fazer perder o sinal.
target.isInterrupted() lê o estado da thread indicada sem o alterar. O método estático Thread.interrupted() lê e limpa apenas o estado da thread atual. Usa isInterrupted() para verificar o estado sem o limpar.
Exemplos
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;
}
}
}Resultado
Before sleep: true In catch: false After pause: true Read and clear: true After clear: false
A thread principal interrompe-se antes de `sleep`. Em `catch`, o estado é `false`; depois de `pause` retornar, é `true` porque foi reposto. `Thread.interrupted()` devolve `true` e limpa o estado, pelo que a última leitura dá `false`.
Lições relacionadas
- Java · Lição 49 · Intermédio · Versão: 2
- Java · Lição 58 · Intermédio · Versão: 2