Java Academy · Aula

O que são threads virtuais

Threads leves no Java 21.

O que são threads virtuais é 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.

Boas-vindas aos encadeamentos virtuais

Os encadeamentos virtuais foram disponibilizados como um recurso definitivo no Java 21 (JEP 444). Eles são encadeamentos leves gerenciados pela JVM, e não pelo sistema operacional.

O objetivo é simples: permitir que você escreva código direto, com um encadeamento por solicitação, e ainda consiga escalar para milhões de tarefas simultâneas.

O problema antigo

Um encadeamento de plataforma tradicional corresponde individualmente a um encadeamento do OS. Cada um consome cerca de um megabyte de pilha e é dispendioso de criar.

Isso significa que você só pode executar alguns milhares de uma vez. A E/S bloqueante mantém um encadeamento inteiro do OS ocupado enquanto ele aguarda.

Como os encadeamentos virtuais são diferentes

Um encadeamento virtual não possui um encadeamento do OS. Muitos encadeamentos virtuais são multiplexados em um pequeno conjunto de encadeamentos de plataforma portadores.

Baratos de criar, milhares por milissegundo
Consumo de memória mínimo
O bloqueio simplesmente suspende o encadeamento virtual, liberando o portador

Montagem e desmontagem

Quando um encadeamento virtual é executado, ele é montado em um encadeamento portador. Quando encontra uma operação bloqueante, ele é desmontado, liberando o portador para que outro trabalho possa prosseguir.

Essa suspensão e retomada acontecem automaticamente. Seu código se parece com um código bloqueante comum.

Um primeiro encadeamento virtual

Este é o exemplo mais simples possível. Thread.ofVirtual().start(...) inicia um encadeamento virtual, e join() espera por ele.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual().start(() ->
            System.out.println("Hello from a virtual thread!"));
        vt.join();
        System.out.println("Main is done.");
    }
}

Confirmando que ele é virtual

Cada Thread oferece isVirtual(). Isso permite verificar em que tipo de encadeamento seu código está sendo executado.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual().start(() -> {
            System.out.println("isVirtual: " + Thread.currentThread().isVirtual());
        });
        vt.join();
    }
}

Escalando para muitas tarefas

Como os encadeamentos virtuais são baratos, iniciar dezenas de milhares deles é perfeitamente normal. Aqui, iniciamos 10.000 deles.

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger counter = new AtomicInteger();
        Thread[] threads = new Thread[10_000];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = Thread.ofVirtual().start(counter::incrementAndGet);
        }
        for (Thread t : threads) t.join();
        System.out.println("Completed: " + counter.get());
    }
}

Nomeando encadeamentos virtuais

Você pode nomear um encadeamento virtual para facilitar a depuração usando o construtor antes de iniciá-lo.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual()
                .name("worker-1")
                .start(() ->
                    System.out.println("Running on: " + Thread.currentThread().getName()));
        vt.join();
    }
}

A mesma API, um novo mecanismo

Os encadeamentos virtuais implementam exatamente a mesma API Thread que você já conhece. Você continua usando start, join, sleep e interrupt.

Isso significa que as bibliotecas existentes criadas com base em Thread e Runnable funcionam sem alterações.

Quando usá-los

Os encadeamentos virtuais se destacam em cargas de trabalho limitadas por E/S: servidores da Web, chamadas a bancos de dados e solicitações a interfaces de programação remotas.

Eles não são mais rápidos para cálculos numéricos limitados pela CPU. Nesse caso, você continua limitado pela quantidade de núcleos.

Não é um conjunto

Uma mudança importante de mentalidade: você não deve agrupar encadeamentos virtuais. Crie um novo para cada tarefa e deixe-o terminar quando a tarefa for concluída.

O agrupamento existe para reutilizar recursos caros. Os encadeamentos virtuais são baratos, portanto agrupá-los é um padrão inadequado.

Verificação rápida

Teste sua compreensão dos encadeamentos virtuais.

Recapitulação

Você aprendeu o que são os encadeamentos virtuais e por que eles são importantes:

Leves, gerenciados pela JVM e finalizados no Java 21
Multiplexados em encadeamentos portadores por meio de montagem e desmontagem
Ideais para trabalho com alta concorrência limitado por E/S
A mesma API Thread, mas criados por tarefa em vez de agrupados

Em seguida, você aprenderá as diferentes formas de criá-los.

Perguntas Frequentes

A aula “O que são threads virtuais” é grátis?

Sim — o texto completo de “O que são 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 “O que são threads virtuais”?

Threads leves no Java 21. 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 que são 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