Java Academy · Aula

Tratamento de erros e cancelamento

Propague falhas de forma limpa.

Tratamento de erros e cancelamento é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Falhas em uma árvore de tarefas

Quando as subtarefas são executadas em paralelo, podem ocorrer erros em qualquer ramo. A concorrência estruturada oferece uma forma disciplinada de propagar essas falhas até a tarefa pai.

Esta lição aborda exceções, cancelamento, interrupção e tempos limite.

Onde as exceções aparecem

Uma subtarefa que lança uma exceção não encerra imediatamente o seu programa. A exceção é capturada na referência Subtask. O local onde ela aparece depende da política:

ShutdownOnFailure: em throwIfFailed()
ShutdownOnSuccess: em result(), se nenhuma tiver tido êxito

Propagando com throwIfFailed

Aqui, uma subtarefa falha. throwIfFailed() a relança encapsulada em ExecutionException, que capturamos em main.

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            scope.fork(() -> "ok");
            scope.fork(() -> { throw new RuntimeException("boom"); });
            scope.join();
            scope.throwIfFailed();
            System.out.println("never reached");
        } catch (ExecutionException e) {
            System.out.println("Caught cause: " + e.getCause().getMessage());
        }
    }
}

Mapeando para uma exceção personalizada

throwIfFailed aceita uma função para encapsular a causa no seu próprio tipo de exceção, mantendo sua interface limpa.

import java.util.concurrent.StructuredTaskScope;

class DataAccessException extends Exception {
    DataAccessException(Throwable cause) { super(cause); }
}

public class Main {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            scope.fork(() -> { throw new RuntimeException("db down"); });
            scope.join();
            scope.throwIfFailed(DataAccessException::new);
        } catch (DataAccessException e) {
            System.out.println("Wrapped: " + e.getCause().getMessage());
        }
    }
}

Cancelamento automático

Quando uma subtarefa falha sob ShutdownOnFailure, o scope cancela as subtarefas irmãs interrompendo seus encadeamentos. Você não precisa escrever nenhum código de cancelamento.

Isso evita trabalho desperdiçado e tarefas pendentes.

A interrupção é o mecanismo

O cancelamento funciona interrompendo o encadeamento virtual da subtarefa. O código cooperativo deve:

Permitir que chamadas bloqueantes lancem InterruptedException
Verificar periodicamente Thread.currentThread().isInterrupted() em loops longos

Respondendo à interrupção

Esta tarefa verifica o sinalizador de interrupção em um loop para poder parar mais cedo quando o scope for encerrado.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().start(() -> {
            long count = 0;
            while (!Thread.currentThread().isInterrupted()) {
                count++;
                if (count == 1_000_000) break;
            }
            System.out.println("Stopped after " + count + " iterations");
        });
        t.join();
    }
}

Prazos com joinUntil

Para limitar o tempo total, use joinUntil(Instant). Se o prazo passar antes que todas as subtarefas terminem, ele lança TimeoutException e o scope encerra o restante.

Estrutura típica com tempo limite

Uma distribuição em paralelo protegida por tempo limite normalmente se parece com isto. O prazo se aplica ao grupo inteiro, não a cada subtarefa individualmente.

import java.time.*;
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            scope.fork(() -> "fast");
            scope.joinUntil(Instant.now().plus(Duration.ofSeconds(2)));
            scope.throwIfFailed();
            System.out.println("Completed within deadline");
        } catch (TimeoutException e) {
            System.out.println("Deadline exceeded");
        } catch (ExecutionException e) {
            System.out.println("A subtask failed");
        }
    }
}

Sempre verifique novamente após join

A disciplina é: depois de join() ou joinUntil, sempre chame throwIfFailed() ou leia result() antes de confiar no valor de qualquer subtarefa. Ignorar essa etapa pode ocultar falhas.

Encerramento limpo garantido

Não importa como um scope termina — normalmente, por falha ou por tempo esgotado —, o fechamento do bloco de tentativa com recursos garante que todos os encadeamentos das subtarefas tenham terminado. Não há vazamentos nem tarefas órfãs.

Verificação rápida

Relembre como as subtarefas irmãs são interrompidas.

Recapitulação

Você aprendeu sobre tratamento de erros e cancelamento:

As exceções aparecem em throwIfFailed() ou result()
Transforme as causas em exceções personalizadas por meio de throwIfFailed(mapper)
O cancelamento funciona por meio da interrupção do encadeamento; escreva tarefas cooperativas
joinUntil impõe um prazo ao grupo
O fechamento do scope sempre faz a limpeza

Isso conclui o curso de Concorrência Estruturada.

Perguntas Frequentes

A aula “Tratamento de erros e cancelamento” é grátis?

Sim — o texto completo de “Tratamento de erros e cancelamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Tratamento de erros e cancelamento”?

Propague falhas de forma limpa. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Tratamento de erros e cancelamento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy