Java Academy · Aula

StructuredTaskScope

Crie subtarefas e aguarde sua conclusão.

StructuredTaskScope é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 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.

Conheça StructuredTaskScope

StructuredTaskScope é a interface central da concorrência estruturada. Você abre um scope, faz fork das subtarefas, usa join para esperar por elas e então lê os resultados.

É um recurso de prévia, portanto compile e execute com --enable-preview.

O ciclo de vida básico

Cada uso segue o mesmo ritmo de quatro etapas:

Abra o scope em um bloco de tentativa com recursos
Use fork para iniciar uma ou mais subtarefas, cada uma retornando uma referência Subtask
Use join para esperar a conclusão
Leia o resultado de cada subtarefa por meio de get()

fork Retorna uma referência

fork(Callable) inicia imediatamente a subtarefa em um encadeamento virtual e retorna uma referência Subtask. Você não deve chamar get() até que join() retorne.

Um exemplo completo

Aqui, duas subtarefas são executadas em paralelo. Ambas devem terminar antes que leiamos os resultados. Este exemplo usa ShutdownOnFailure, uma política integrada.

import java.util.concurrent.StructuredTaskScope;

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

join e depois leia

A regra de ordenação é rigorosa: fork, depois join e então get. Chamar get() em uma subtarefa antes que join() termine lança IllegalStateException.

É essa regra que mantém o ciclo de vida estruturado.

Estados das subtarefas

Após join(), cada Subtask informa um state():

SUCCESS com um resultado de get()
FAILED com a exceção de exception()
UNAVAILABLE se nunca tiver sido concluída

Muitas subtarefas

Você pode fazer fork de quantas subtarefas quiser; cada uma recebe seu próprio encadeamento virtual. É assim que você distribui um lote de chamadas independentes.

import java.util.*;
import java.util.concurrent.StructuredTaskScope;

public class Main {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            List<StructuredTaskScope.Subtask<Integer>> tasks = new ArrayList<>();
            for (int i = 1; i <= 5; i++) {
                final int n = i;
                tasks.add(scope.fork(() -> n * n));
            }
            scope.join();
            scope.throwIfFailed();
            int total = tasks.stream().mapToInt(StructuredTaskScope.Subtask::get).sum();
            System.out.println("Sum of squares 1..5 = " + total);
        }
    }
}

O scope possui os encadeamentos

O scope é um AutoCloseable. Quando o bloco de tentativa termina, close() garante que todos os encadeamentos das subtarefas tenham terminado. Não há possibilidade de vazamentos.

É por isso que você sempre o utiliza dentro de um bloco de tentativa com recursos.

Políticas integradas

O JDK fornece duas políticas de encerramento prontas:

ShutdownOnFailure: cancela as demais se alguma subtarefa falhar
ShutdownOnSuccess: cancela as demais assim que uma tiver êxito

Você também pode criar uma subclasse de StructuredTaskScope para implementar uma lógica personalizada.

O mesmo encadeamento faz join

Somente o encadeamento que abriu o scope pode fazer fork nele e chamar join. As subtarefas ficam restritas ao scope que as possui, o que mantém a árvore bem formada.

Opções de compilação e execução

Como a interface é uma prévia, compile com:

javac --release 21 --enable-preview Main.java
java --enable-preview Main

Sem a opção, você recebe um erro de compilação ou de execução.

Verificação rápida

Relembre a ordem obrigatória das chamadas.

Recapitulação

Você aprendeu a interface StructuredTaskScope:

Abra em um bloco de tentativa com recursos, use fork, join e depois get
Cada subtarefa é executada em seu próprio encadeamento virtual
O scope garante que todas as subtarefas terminem antes do fechamento
Requer --enable-preview

A seguir: as políticas de encerramento em caso de falha e em caso de sucesso, em detalhes.

Perguntas Frequentes

A aula “StructuredTaskScope” é grátis?

Sim — o texto completo de “StructuredTaskScope” é 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 “StructuredTaskScope”?

Crie subtarefas e aguarde sua conclusão. 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 2 de 4.

Quanto tempo leva a aula “StructuredTaskScope”?

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