Java Academy · Aula

Criando threads virtuais

Thread.ofVirtual e executores.

Criando threads virtuais é 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.

Formas de criar encadeamentos virtuais

Java oferece vários pontos de entrada para criar encadeamentos virtuais. Os dois mais importantes são o construtor Thread.ofVirtual() e a fábrica Executors.newVirtualThreadPerTaskExecutor().

Esta lição apresenta cada um deles.

O construtor: start

Thread.ofVirtual() retorna um construtor. Chamar .start(runnable) cria e inicia imediatamente o encadeamento.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().start(() ->
            System.out.println("Started directly"));
        t.join();
    }
}

O construtor: unstarted

Use .unstarted(runnable) quando quiser configurar o encadeamento e iniciá-lo mais tarde.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().unstarted(() ->
            System.out.println("Started later"));
        System.out.println("Before start, alive? " + t.isAlive());
        t.start();
        t.join();
    }
}

Uma fábrica reutilizável

O construtor pode produzir uma ThreadFactory por meio de .factory(). Cada chamada a newThread produz um novo encadeamento virtual.

import java.util.concurrent.ThreadFactory;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ThreadFactory factory = Thread.ofVirtual().name("job-", 0).factory();
        Thread a = factory.newThread(() ->
            System.out.println(Thread.currentThread().getName()));
        Thread b = factory.newThread(() ->
            System.out.println(Thread.currentThread().getName()));
        a.start(); b.start();
        a.join(); b.join();
    }
}

O método conveniente

Thread.startVirtualThread(runnable) é uma forma abreviada de criar e iniciar um encadeamento virtual sem nome em uma única chamada.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.startVirtualThread(() ->
            System.out.println("One-liner virtual thread"));
        t.join();
    }
}

A abordagem com executor

Para código orientado a tarefas, prefira Executors.newVirtualThreadPerTaskExecutor(). Ele cria um novo encadeamento virtual para cada tarefa enviada.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            exec.submit(() -> System.out.println("task one"));
            exec.submit(() -> System.out.println("task two"));
        }
        System.out.println("All tasks submitted and completed");
    }
}

Por que usar try com recursos

Desde Java 19, ExecutorService implementa AutoCloseable. Fechá-lo em um bloco de try com recursos aguarda a conclusão de todas as tarefas enviadas.

Isso proporciona um encerramento limpo e estruturado, sem chamadas manuais a shutdown e awaitTermination.

Enviando muitas tarefas

O executor por tarefa lida sem esforço com um grande número de tarefas. Cada tarefa recebe seu próprio encadeamento virtual.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        AtomicInteger sum = new AtomicInteger();
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 1; i <= 1000; i++) {
                final int n = i;
                exec.submit(() -> sum.addAndGet(n));
            }
        }
        System.out.println("Sum 1..1000 = " + sum.get());
    }
}

Coletando resultados com um futuro

submit retorna um Future, portanto você pode coletar valores de retorno assim como faria com qualquer executor.

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            Future<Integer> f = exec.submit(() -> 6 * 7);
            System.out.println("Result: " + f.get());
        }
    }
}

Construtor versus executor

Escolha com base na intenção:

Construtor / startVirtualThread para encadeamentos pontuais ou nomenclatura personalizada
newVirtualThreadPerTaskExecutor para enviar coleções de tarefas e coletar resultados

Ambos criam um encadeamento virtual por unidade de trabalho, exatamente como você precisa.

Nunca armazene um executor virtual em cache

Não reutilize um único executor de encadeamentos virtuais como se fosse um conjunto fixo de trabalhadores. O executor em si pode ser reutilizado, mas lembre-se de que cada tarefa inicia um encadeamento completamente novo.

O ponto é: não há agrupamento de encadeamentos, apenas um envio conveniente de tarefas.

Verificação rápida

Escolha a melhor forma de executar um grande lote de tarefas, cada uma em seu próprio encadeamento virtual.

Recapitulação

Agora você sabe como criar encadeamentos virtuais:

Thread.ofVirtual().start(...) e .unstarted(...)
Thread.startVirtualThread(...) em uma única linha
.factory() para uma ThreadFactory reutilizável
Executors.newVirtualThreadPerTaskExecutor() com try com recursos

Em seguida: escolher entre encadeamentos de plataforma e virtuais.

Perguntas Frequentes

A aula “Criando threads virtuais” é grátis?

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

Thread.ofVirtual e executores. 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 “Criando threads virtuais”?

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