No exemplo de timeout, notei que quando o timeout ocorre, a thread cliente ainda continua em execução. A motivação seria para um retry e/ou tratamento? Caso queira finalizar essa thread cliente, deveria ser feito manualmente dentro do catch?
Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!
No exemplo de timeout, notei que quando o timeout ocorre, a thread cliente ainda continua em execução. A motivação seria para um retry e/ou tratamento? Caso queira finalizar essa thread cliente, deveria ser feito manualmente dentro do catch?
Correto, no exemplo anterior, a thread cliente continua em execução mesmo após o timeout ocorrer. Isso acontece porque o mecanismo de retry foi projetado para tentar novamente a tarefa em caso de falha, e não para finalizar automaticamente a thread cliente.
Se você deseja finalizar a thread cliente quando o timeout ocorre ou quando todas as tentativas são esgotadas, é necessário fazer isso manualmente dentro do catch. Você pode interromper a execução da thread chamando o método Thread.interrupt(), o que irá lançar uma InterruptedException na thread.
Aqui está uma modificação no exemplo anterior para interromper a thread cliente após o timeout ou quando todas as tentativas são esgotadas:
public class RetryThread implements Runnable {
private int maxRetries;
private long retryDelay;
private boolean success;
public RetryThread(int maxRetries, long retryDelay) {
this.maxRetries = maxRetries;
this.retryDelay = retryDelay;
this.success = false;
}
@Override
public void run() {
int retries = 0;
while (!success && retries < maxRetries) {
try {
// Realize a tarefa que você deseja executar na thread aqui
// Por exemplo, uma operação de rede ou IO que pode lançar um TimeoutException
// Simule um cenário de timeout
throw new TimeoutException("Operação expirou");
// Se a tarefa for concluída com sucesso, defina a variável success como true
// success = true;
} catch (TimeoutException e) {
System.out.println("Timeout da tarefa, tentando novamente...");
retries++;
if (retries >= maxRetries) {
System.out.println("Tentativas esgotadas, interrompendo a thread.");
Thread.currentThread().interrupt(); // Interrompe a execução da thread
} else {
// Aguarde o tempo de atraso antes de tentar novamente
try {
Thread.sleep(retryDelay);
} catch (InterruptedException ex) {
System.out.println("Thread interrompida durante o atraso.");
Thread.currentThread().interrupt(); // Interrompe a execução da thread
return; // Sai da thread
}
}
}
}
if (success) {
System.out.println("Tarefa concluída com sucesso!");
} else {
System.out.println("Tentativas esgotadas, não foi possível concluir a tarefa.");
}
}
public static void main(String[] args) {
int maxRetries = 5;
long retryDelay = 1000;
RetryThread retryThread = new RetryThread(maxRetries, retryDelay);
Thread thread = new Thread(retryThread);
thread.start();
}
}
Nesta versão modificada, ao atingir o número máximo de tentativas (retries >= maxRetries), a thread cliente é interrompida usando Thread.currentThread().interrupt(). Também tratamos a interrupção durante o atraso, caso ocorra uma InterruptedException. É importante lembrar que, ao interromper uma thread, você deve garantir que a lógica dentro da thread esteja preparada para lidar com a exceção InterruptedException e realizar uma saída adequada e limpa.