Java Academy · Aula

O modelo de concorrência estruturada

Trate tarefas relacionadas como uma unidade.

O modelo de concorrência estruturada é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 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.

O que é concorrência estruturada

Concorrência estruturada (JEP 453, versão de prévia) trata um grupo de tarefas concorrentes relacionadas como uma única unidade de trabalho.

Se a tarefa pai se divide em subtarefas, todas elas precisam ser concluídas antes que a tarefa pai prossiga, assim como em um escopo de bloco no código comum.

O problema que ela resolve

Com executores simples, uma tarefa iniciada pode continuar após seu criador, escapar ou ser esquecida. Erros em um ramo podem passar despercebidos enquanto outros continuam em execução.

Isso resulta em vazamentos de encadeamentos, trabalho órfão e tratamento confuso de falhas.

Tarefas como uma árvore

A concorrência estruturada impõe uma relação entre pai e filho. As subtarefas formam uma árvore cuja raiz é a tarefa que as iniciou.

Uma subtarefa não pode sobreviver ao escopo pai
A tarefa pai espera todas as filhas terminarem
O cancelamento se propaga pela árvore

Espelhando código sequencial

A grande ideia é que o código concorrente deve ser lido como código sequencial. Um escopo é aberto, o trabalho é ramificado e o escopo só é encerrado depois que tudo termina.

Isso torna evidentes os tempos de vida e facilita o raciocínio sobre os erros.

A antiga abordagem não estruturada

Aqui está uma abordagem conhecida, mas não estruturada, usando um executor simples. Ela funciona, mas nada garante que os dois futuros compartilhem um tempo de vida coordenado.

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            Future<String> user = exec.submit(() -> "Ada");
            Future<Integer> order = exec.submit(() -> 7);
            System.out.println(user.get() + " has " + order.get() + " orders");
        }
    }
}

Por que a coordenação importa

No exemplo anterior, se a busca pelo usuário falhar, a tarefa de buscar o pedido continua sendo executada sem propósito. Você precisa cancelá-la manualmente e tratar as exceções de cada chamada a get().

A concorrência estruturada automatiza essa coordenação.

Status de prévia

A concorrência estruturada é fornecida como uma interface de prévia no pacote java.util.concurrent. Para usá-la, compile e execute com --enable-preview.

A classe central é StructuredTaskScope, apresentada na próxima lição.

Garantias do ciclo de vida

Dentro de um scope estruturado:

Todas as subtarefas são concluídas, falham ou são canceladas antes que o scope termine
Nenhuma subtarefa escapa para a execução em segundo plano
A pilha de chamadas reflete a hierarquia real das tarefas nos despejos de encadeamentos

Benefício de observabilidade

Como a árvore de subtarefas é explícita, as ferramentas do JDK podem mostrá-la. Um despejo de encadeamentos agrupa as subtarefas sob o scope pai, tornando o diagnóstico muito mais claro do que quando há encadeamentos de pools espalhados.

Combina bem com encadeamentos virtuais

Cada subtarefa em um scope estruturado é executada em seu próprio encadeamento virtual por padrão. O baixo custo dos encadeamentos virtuais é o que torna prática a distribuição em muitas subtarefas.

Os dois recursos foram projetados para trabalhar em conjunto.

Modelo mental

Pense em um scope estruturado como um bloco de tentativa com recursos para concorrência: você o abre, faz fork do trabalho, usa join e depois o fecha. A chave de fechamento é a garantia de que nada continuará em execução.

Verificação rápida

Teste sua compreensão do princípio central.

Recapitulação

Você conheceu o modelo de concorrência estruturada:

Tarefas relacionadas formam uma árvore vinculada ao ciclo de vida de um scope
O código concorrente se lê como código sequencial
É uma interface de prévia que requer --enable-preview
Combina naturalmente com encadeamentos virtuais

A seguir: a própria interface StructuredTaskScope.

Perguntas Frequentes

A aula “O modelo de concorrência estruturada” é grátis?

Sim — o texto completo de “O modelo de concorrência estruturada” é 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 “O modelo de concorrência estruturada”?

Trate tarefas relacionadas como uma unidade. 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 1 de 4.

Quanto tempo leva a aula “O modelo de concorrência estruturada”?

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