Java Academy · Aula

Threads de plataforma e virtuais

Saiba quando cada uma é adequada.

Threads de plataforma e virtuais é 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 tipos de encadeamentos

Java agora tem dois tipos de encadeamentos. Encadeamentos de plataforma são os invólucros clássicos em torno dos encadeamentos do sistema operacional. Encadeamentos virtuais são leves e gerenciados pela JVM.

Saber quando recorrer a cada tipo é fundamental para escrever código Java concorrente e escalável.

Criando um encadeamento de plataforma

Você cria um encadeamento de plataforma com Thread.ofPlatform(), o equivalente a Thread.ofVirtual().

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread p = Thread.ofPlatform().name("native-worker").start(() ->
            System.out.println("Platform? " + !Thread.currentThread().isVirtual()));
        p.join();
    }
}

Comparação de custos

Os encadeamentos de plataforma são pesados:

~1 MB de pilha reservada por encadeamento
Criação lenta
Limitados a alguns milhares

Os encadeamentos virtuais são baratos: pilha inicial pequena, criação rápida e possibilidade de chegar a milhões.

Trabalho limitado por E/S

Se sua tarefa passa a maior parte do tempo esperando pela rede, pelo disco ou por um banco de dados, os encadeamentos virtuais oferecem uma grande vantagem.

Enquanto um encadeamento virtual está bloqueado, seu portador é liberado para executar outros, portanto alguns encadeamentos do sistema operacional podem atender a milhares de solicitações.

Trabalho limitado por CPU

Para computação pura que nunca bloqueia, os encadeamentos virtuais não oferecem ganho de velocidade. Você está limitado pela quantidade de núcleos.

Nesse caso, a ferramenta adequada é um conjunto fixo dimensionado de acordo com os processadores.

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        int cores = Runtime.getRuntime().availableProcessors();
        try (ExecutorService cpu = Executors.newFixedThreadPool(cores)) {
            Future<Long> f = cpu.submit(() -> {
                long s = 0;
                for (long i = 0; i < 1_000_000L; i++) s += i;
                return s;
            });
            System.out.println("Cores: " + cores + ", sum: " + f.get());
        }
    }
}

Simulando bloqueio

Este trecho mostra muitos encadeamentos virtuais dormindo simultaneamente, como representação de E/S bloqueante. Tente imaginar 10.000 encadeamentos de plataforma fazendo o mesmo.

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        AtomicInteger done = new AtomicInteger();
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10_000; i++) {
                exec.submit(() -> {
                    try { Thread.sleep(50); } catch (InterruptedException e) {}
                    done.incrementAndGet();
                });
            }
        }
        System.out.println("Finished blocking tasks: " + done.get());
    }
}

Status de segundo plano

Os encadeamentos virtuais são sempre encadeamentos de segundo plano e não podem ser transformados em encadeamentos comuns. Por padrão, os encadeamentos de plataforma herdam o status de segundo plano de seu criador, mas esse status pode ser definido explicitamente.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread v = Thread.ofVirtual().unstarted(() -> {});
        Thread p = Thread.ofPlatform().unstarted(() -> {});
        System.out.println("virtual daemon: " + v.isDaemon());
        System.out.println("platform daemon: " + p.isDaemon());
    }
}

Prioridades ignoradas

Os encadeamentos virtuais sempre informam uma prioridade de NORM_PRIORITY, e definir a prioridade não produz efeito. A JVM gerencia o agendamento, não o agendador do sistema operacional.

public class Main {
    public static void main(String[] args) {
        Thread v = Thread.ofVirtual().unstarted(() -> {});
        v.setPriority(Thread.MAX_PRIORITY);
        System.out.println("Priority is still: " + v.getPriority());
    }
}

Diretriz para decisão

Uma regra prática:

Muitas tarefas que esperam por E/S? Use encadeamentos virtuais.
Computação pesada limitada pela CPU? Use um conjunto fixo de encadeamentos de plataforma.
Precisa ajustar encadeamentos no nível do sistema operacional, como prioridade ou afinidade? Use encadeamentos de plataforma.

Eles coexistem

Você não precisa escolher um único tipo para todo o programa. Um aplicativo típico usa encadeamentos virtuais para tratar solicitações e um conjunto pequeno de encadeamentos de plataforma para seções que exigem muita CPU.

Ambos compartilham a mesma interface Thread, portanto misturá-los é simples.

Dica de migração

Ao migrar um serviço com uso intenso de E/S, a menor alteração é trocar o executor: substitua um conjunto fixo ou armazenado em cache por newVirtualThreadPerTaskExecutor().

Apenas tome cuidado com a fixação e o uso indevido de ThreadLocal, abordados na próxima lição.

Verificação rápida

Escolha a carga de trabalho em que os encadeamentos virtuais oferecem o benefício mais evidente.

Recapitulação

Você comparou os dois modelos de encadeamento:

Encadeamentos de plataforma: pesados, apoiados pelo sistema operacional e ideais para trabalho limitado pela CPU e ajustes no sistema operacional
Encadeamentos virtuais: baratos, gerenciados pela JVM, sempre de segundo plano e ideais para concorrência limitada por E/S
Eles coexistem e compartilham a mesma interface

Em seguida: os problemas de fixação e ThreadLocals.

Perguntas Frequentes

A aula “Threads de plataforma e virtuais” é grátis?

Sim — o texto completo de “Threads de plataforma e 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 “Threads de plataforma e virtuais”?

Saiba quando cada uma é adequada. 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 “Threads de plataforma e 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