Como tratar InterruptedException ao trabalhar com threads?

Como tratar InterruptedException ao trabalhar com threads?

O erro InterruptedException ocorre quando uma thread em espera ou bloqueada é interrompida por outra thread. Esse erro é comum ao usar métodos como Thread.sleep(), wait(), join() ou BlockingQueue.take().

Causas comuns do erro InterruptedException

Uma thread foi interrompida enquanto dormia (sleep()). Uma thread esperava um bloqueio (wait()) e foi interrompida. Uso de join() para aguardar outra thread ser finalizada, mas a thread foi interrompida antes disso.

Exemplo de erro e solução

Código que gera o erro:

class MinhaThread extends Thread {
    public void run() {
        try {
            System.out.println("Thread em execução...");
            Thread.sleep(5000); // Pode ser interrompida aqui
            System.out.println("Thread finalizada!");
        } catch (InterruptedException e) {
            System.out.println("Thread foi interrompida!");
        }
    }
}

public class Exemplo {
    public static void main(String[] args) {
        MinhaThread thread = new MinhaThread();
        thread.start();

        try {
            Thread.sleep(2000);
            thread.interrupt(); // Interrompe a thread
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Nesse exemplo, a thread foi interrompida enquanto dormia, lançando InterruptedException. A solução correta é capturar a exceção e decidir se deve reiniciar a execução ou encerrar a thread de maneira segura.

Como evitar e tratar InterruptedException?

Verifique se a thread foi interrompida antes de executar operações demoradas. Sempre capture e trate InterruptedException adequadamente. Use Thread.interrupted() para verificar e responder a interrupções corretamente.

class MinhaThread implements Runnable {
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                System.out.println("Thread em execução...");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                System.out.println("Thread interrompida! Finalizando...");
                Thread.currentThread().interrupt(); // Restaura o status de interrupção
                break;
            }
        }
    }
}

public class Exemplo {
    public static void main(String[] args) {
        Thread thread = new Thread(new MinhaThread());
        thread.start();

        try {
            Thread.sleep(2000);
            thread.interrupt(); // Envia sinal de interrupção
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Aqui, usamos Thread.currentThread().interrupt() dentro do bloco catch para manter o estado de interrupção da thread, garantindo que a interrupção seja tratada corretamente.

Conclusão

O erro InterruptedException é comum ao trabalhar com threads e deve ser tratado corretamente para evitar falhas inesperadas. A melhor prática é verificar regularmente o status da thread e interrompê-la de forma segura quando necessário.

Como lidar corretamente com interrupções de threads em Java?

InterruptedException é um erro essencial ao lidar com concorrência em Java. Ele ocorre quando uma thread em espera é interrompida, podendo causar falhas inesperadas se não for tratada corretamente. Com boas práticas, podemos garantir um controle mais seguro e eficiente da execução das threads.

Algumas aplicações:

• Evitar bloqueios inesperados ao executar operações concorrentes
• Garantir um fluxo seguro de execução de threads
• Prevenir falhas ao lidar com tarefas que dependem de múltiplas threads
• Melhorar a eficiência no gerenciamento de processos concorrentes

Dicas para quem está começando

• Use Thread.interrupted() para verificar se a thread foi interrompida
• Capture e trate InterruptedException corretamente
• Evite operações longas sem verificar a possibilidade de interrupção
• Garanta que a interrupção seja restaurada quando apropriado

Compartilhe este tutorial