Java Academy · Aula

Encerramento em caso de falha e sucesso

Coordene os resultados das tarefas.

Encerramento em caso de falha e sucesso é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 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.

Dois padrões comuns

A maior parte da distribuição concorrente se encaixa em dois formatos:

Todas devem ter êxito: se alguma falhar, abandone as demais. Use ShutdownOnFailure.
A primeira vence: assim que uma tiver êxito, cancele as demais. Use ShutdownOnSuccess.

O JDK fornece ambas prontas para uso.

Ideia de ShutdownOnFailure

ShutdownOnFailure é usado quando todas as tarefas precisam ter êxito, como ao reunir o perfil de um usuário e seus pedidos.

Se uma subtarefa lançar uma exceção, o scope cancela as outras para que você não desperdice esforço.

Exemplo de ShutdownOnFailure

Após join(), você chama throwIfFailed(), que relança a primeira falha, se houver, encapsulada em uma ExecutionException.

import java.util.concurrent.StructuredTaskScope;

public class Main {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var a = scope.fork(() -> fetch("profile"));
            var b = scope.fork(() -> fetch("orders"));
            scope.join();
            scope.throwIfFailed();
            System.out.println(a.get() + " + " + b.get());
        }
    }

    static String fetch(String what) {
        return what + "-ok";
    }
}

O que throwIfFailed faz

throwIfFailed() inspeciona as subtarefas. Se todas tiverem êxito, não faz nada. Se alguma tiver falhado, lança uma exceção que encapsula a exceção original.

Você também pode passar uma função para transformar a causa em um tipo de exceção personalizado.

Ideia de ShutdownOnSuccess

ShutdownOnSuccess é usado para redundância ou competição: consulte vários espelhos e aceite a resposta que chegar primeiro.

No momento em que uma subtarefa tem êxito, o scope cancela as demais e armazena o resultado vencedor.

Exemplo de ShutdownOnSuccess

Você recupera o valor vencedor com result(). Ele lança uma exceção se nenhuma subtarefa tiver tido êxito.

import java.util.concurrent.StructuredTaskScope;

public class Main {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
            scope.fork(() -> queryMirror("eu"));
            scope.fork(() -> queryMirror("us"));
            scope.join();
            System.out.println("Fastest answer: " + scope.result());
        }
    }

    static String queryMirror(String region) {
        return region + "-data";
    }
}

resultado vs get

Observe a diferença:

ShutdownOnFailure: leia cada subtarefa com seu próprio get()
ShutdownOnSuccess: leia o único vencedor com o result() do scope

O cancelamento é cooperativo

Quando um scope é encerrado, ele interrompe os encadeamentos das subtarefas restantes. Tarefas bem comportadas verificam a interrupção e param prontamente.

Chamadas bloqueantes da biblioteca padrão geralmente respondem à interrupção automaticamente.

join com tempo limite

Ambas as políticas aceitam um prazo. Chamar joinUntil(Instant) espera somente até determinado momento e então lança TimeoutException e encerra o scope.

Escolhendo a política

Faça a si mesmo uma pergunta: preciso de todos os resultados ou apenas do primeiro?

Todos os resultados, falhando rapidamente em caso de erro: ShutdownOnFailure
Qualquer resultado, vencendo o mais rápido: ShutdownOnSuccess

Para qualquer outra situação, crie uma subclasse de StructuredTaskScope.

Políticas personalizadas

Você pode estender StructuredTaskScope e substituir handleComplete(Subtask) para implementar regras específicas, como coletar os primeiros N êxitos ou encerrar após uma quantidade determinada de falhas.

Verificação rápida

Associe o cenário à política.

Recapitulação

Você aprendeu as duas políticas de encerramento integradas:

ShutdownOnFailure + throwIfFailed + get por subtarefa quando todas devem ter êxito
ShutdownOnSuccess + result quando a primeira vence
O encerramento interrompe cooperativamente as subtarefas restantes
joinUntil acrescenta prazos; a criação de subclasses acrescenta regras personalizadas

A seguir: tratamento de erros e cancelamento em detalhes.

Perguntas Frequentes

A aula “Encerramento em caso de falha e sucesso” é grátis?

Sim — o texto completo de “Encerramento em caso de falha e sucesso” é 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 “Encerramento em caso de falha e sucesso”?

Coordene os resultados das tarefas. 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 3 de 4.

Quanto tempo leva a aula “Encerramento em caso de falha e sucesso”?

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