Java Academy · Leçon

Threads de plateforme ou virtuels

Quand utiliser chacun

Threads de plateforme ou virtuels est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Deux types de threads

Java dispose désormais de deux variantes de threads. Les threads de plateforme sont les enveloppes classiques autour des threads de l'OS. Les threads virtuels sont légers et gérés par la JVM.

Savoir quand choisir l'un ou l'autre est essentiel pour écrire du code Java concurrent et évolutif.

Créer un thread de plateforme

Vous créez un thread de plateforme avec Thread.ofPlatform(), l'équivalent de 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();
    }
}

Comparaison des coûts

Les threads de plateforme sont lourds :

Environ 1 MB de pile réservée chacun
Lents à créer
Limité à quelques milliers

Les threads virtuels sont peu coûteux : pile initiale réduite, création rapide et possibilité d'en utiliser des millions.

Tâches liées aux E/S

Si votre tâche passe la plupart de son temps à attendre le réseau, un disque ou une base de données, les threads virtuels sont nettement plus performants.

Lorsqu'un thread virtuel est bloqué, son thread porteur est libéré pour en exécuter d'autres. Ainsi, quelques threads de l'OS peuvent servir des milliers de requêtes.

Tâches limitées par le CPU

Pour un calcul pur qui ne se bloque jamais, les threads virtuels n'apportent aucun gain de vitesse. Vous êtes limité par le nombre de cœurs.

Dans ce cas, un groupe fixe dimensionné selon le nombre de processeurs est l'outil approprié.

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());
        }
    }
}

Simuler un blocage

Cet extrait montre de nombreux threads virtuels qui dorment simultanément, pour simuler des E/S bloquantes. Imaginez maintenant 10 000 threads de plateforme faisant la même chose.

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());
    }
}

État démon

Les threads virtuels sont toujours des threads démon et ne peuvent pas devenir des threads non-démon. Par défaut, les threads de plateforme héritent de l'état démon de leur créateur, mais cet état peut être défini explicitement.

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());
    }
}

Priorités ignorées

Les threads virtuels indiquent toujours une priorité égale à NORM_PRIORITY, et définir leur priorité n'a aucun effet. La planification est gérée par la JVM, et non par le planificateur de l'OS.

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());
    }
}

Principe directeur

Voici une règle pratique :

Beaucoup de tâches qui attendent des E/S ? Utilisez des threads virtuels.
Calculs lourds limités par le CPU ? Utilisez un groupe fixe de threads de plateforme.
Besoin d'un réglage des threads au niveau de l'OS, comme la priorité ou l'affinité ? Utilisez des threads de plateforme.

Ils coexistent

Vous n'avez pas à choisir un seul type pour tout le programme. Une application courante utilise des threads virtuels pour traiter les requêtes et un petit groupe de threads de plateforme pour les sections intensives en calcul.

Les deux partagent la même interface Thread, leur combinaison est donc transparente.

Conseil pour la migration

Lors de la migration d'un service fortement axé sur les E/S, le changement le plus simple consiste à remplacer l'exécuteur : remplacez un groupe fixe ou mis en cache par newVirtualThreadPerTaskExecutor().

Faites simplement attention à l'épinglage et à l'utilisation abusive de ThreadLocal, qui seront abordés dans la prochaine leçon.

Vérification rapide

Choisissez la charge de travail pour laquelle les threads virtuels offrent l'avantage le plus évident.

Récapitulatif

Vous avez comparé les deux modèles de threads :

Threads de plateforme : lourds, pris en charge par l'OS, adaptés aux tâches limitées par le CPU et au réglage de l'OS
Threads virtuels : peu coûteux, gérés par la JVM, toujours des démons, adaptés à la concurrence liée aux E/S
Ils coexistent et partagent la même interface de programmation

Ensuite : les pièges de l'épinglage et des ThreadLocals.

Questions Fréquemment Posées

La leçon « Threads de plateforme ou virtuels » est-elle gratuite ?

Oui — le texte complet de « Threads de plateforme ou virtuels » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Threads de plateforme ou virtuels » ?

Quand utiliser chacun Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Threads de plateforme ou virtuels » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy