Java Academy · Leçon

Que sont les threads virtuels

Des threads légers dans Java 21

Que sont les threads virtuels est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Bienvenue dans les fils virtuels

Les fils virtuels sont devenus une fonctionnalité définitive de Java 21 (JEP 444). Ce sont des fils légers gérés par la JVM plutôt que par le système d'exploitation.

L'objectif est simple : vous permettre d'écrire du code simple, avec un fil par requête, tout en passant à l'échelle de millions de tâches simultanées.

L'ancien problème

Un fil de plateforme correspond un à un à un fil du système d'exploitation. Chacun consomme environ un mégaoctet de pile et coûte cher à créer.

Vous ne pouvez donc en exécuter que quelques milliers à la fois. Les entrées-sorties bloquantes monopolisent un fil entier du système d'exploitation pendant son attente.

Ce qui différencie les fils virtuels

Un fil virtuel ne possède pas de fil du système d'exploitation. De nombreux fils virtuels sont multiplexés sur un petit groupe de fils de plateforme porteurs.

Création peu coûteuse, par milliers chaque milliseconde
Très faible empreinte mémoire
Une opération bloquante met simplement le fil virtuel en attente et libère le fil porteur

Montage et démontage

Lorsqu'un fil virtuel s'exécute, il est monté sur un fil porteur. Lorsqu'il rencontre une opération bloquante, il est démonté, libérant le fil porteur pour que d'autres tâches puissent progresser.

Cette mise en attente suivie d'une reprise se fait automatiquement. Votre code se lit comme du code bloquant ordinaire.

Un premier fil virtuel

Voici l'exemple le plus simple possible. Thread.ofVirtual().start(...) démarre un fil virtuel et join() attend qu'il se termine.

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.");
    }
}

Vérifier qu'il est virtuel

Chaque Thread expose isVirtual(). Vous pouvez ainsi vérifier sur quel type de fil votre code s'exécute.

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

Passer à l'échelle avec de nombreuses tâches

Comme les fils virtuels sont peu coûteux, en lancer des dizaines de milliers est parfaitement normal. Ici, nous en créons 10 000.

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

Nommer les fils virtuels

Vous pouvez nommer un fil virtuel pour faciliter le débogage à l'aide du générateur avant de le démarrer.

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

La même API, un nouveau moteur

Les fils virtuels implémentent exactement la même API Thread que celle que vous connaissez déjà. Vous utilisez toujours start, join, sleep et interrupt.

Les bibliothèques existantes fondées sur Thread et Runnable fonctionnent donc sans modification.

Quand les utiliser

Les threads virtuels sont particulièrement adaptés aux charges de travail liées aux E/S : serveurs Internet, appels à des bases de données et requêtes vers des interfaces de programmation distantes.

Ils ne sont pas plus rapides pour les calculs intensifs limités par le CPU. Dans ce cas, vous restez limité par le nombre de cœurs.

Pas de mise en commun

Il faut changer de perspective : vous ne regroupez pas les threads virtuels. Créez-en un nouveau pour chaque tâche et laissez-le se terminer quand la tâche est finie.

La mise en commun sert à réutiliser des ressources coûteuses. Les threads virtuels sont peu coûteux, leur mise en commun est donc une pratique à éviter.

Vérification rapide

Vérifiez votre compréhension des threads virtuels.

Récapitulatif

Vous avez appris ce que sont les threads virtuels et pourquoi ils sont importants :

Légers, gérés par la JVM et finalisés dans Java 21
Multiplexés sur des threads porteurs via le montage et le démontage
Idéaux pour les tâches fortement concurrentes liées aux E/S
Même interface Thread, mais créés pour chaque tâche plutôt que regroupés

Vous allez maintenant découvrir les différentes façons de les créer.

Questions Fréquemment Posées

La leçon « Que sont les threads virtuels » est-elle gratuite ?

Oui — le texte complet de « Que sont les threads 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 « Que sont les threads virtuels » ?

Des threads légers dans Java 21 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 1 sur 4.

Combien de temps prend la leçon « Que sont les threads 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