Java Academy · Leçon

Créer des threads virtuels

Thread.ofVirtual et exécuteurs

Leçon 2 sur 413 étapes

Créer des threads virtuels est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Façons de créer des threads virtuels

Java propose plusieurs points d'entrée pour créer des threads virtuels. Les deux plus importants sont le générateur Thread.ofVirtual() et la fabrique Executors.newVirtualThreadPerTaskExecutor().

Cette leçon présente chacun d'eux.

Le générateur : start

Thread.ofVirtual() renvoie un générateur. L'appel à .start(runnable) crée le thread et le démarre immédiatement.

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

Le générateur : unstarted

Utilisez .unstarted(runnable) lorsque vous souhaitez configurer le thread et le démarrer plus tard.

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

Une fabrique réutilisable

Le générateur peut produire une ThreadFactory grâce à .factory(). Chaque appel à newThread fournit un nouveau thread virtuel.

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

La méthode pratique

Thread.startVirtualThread(runnable) est une forme abrégée qui permet de créer et de démarrer un thread virtuel sans nom en un seul appel.

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

L'approche avec un exécuteur

Pour le code organisé autour de tâches, préférez Executors.newVirtualThreadPerTaskExecutor(). Il crée un nouveau thread virtuel pour chaque tâche soumise.

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

Pourquoi utiliser la gestion automatique des ressources

Depuis Java 19, ExecutorService implémente AutoCloseable. Sa fermeture dans un bloc de gestion automatique des ressources attend la fin de toutes les tâches soumises.

Vous obtenez ainsi un arrêt propre et structuré, sans appels manuels à shutdown et awaitTermination.

Soumettre de nombreuses tâches

L'exécuteur qui crée un thread par tâche gère sans difficulté un très grand nombre de tâches. Chaque tâche obtient son propre thread virtuel.

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

Collecter des résultats avec une promesse

submit renvoie une Future, ce qui vous permet de récupérer les valeurs renvoyées comme avec n'importe quel exécuteur.

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

Générateur ou exécuteur

Choisissez selon votre intention :

Générateur / startVirtualThread pour les threads ponctuels ou les noms personnalisés
newVirtualThreadPerTaskExecutor pour soumettre des collections de tâches et récupérer les résultats

Les deux créent un thread virtuel par unité de travail, ce qui correspond exactement à votre besoin.

Ne mettez jamais en cache un exécuteur virtuel

Ne réutilisez pas un seul exécuteur de threads virtuels comme s'il s'agissait d'un groupe fixe de travailleurs. Vous pouvez réutiliser l'exécuteur lui-même, mais n'oubliez pas que chaque tâche crée un thread entièrement nouveau.

L'idée essentielle est qu'il n'y a pas de mise en commun des threads, seulement une soumission pratique des tâches.

Vérification rapide

Choisissez la meilleure façon d'exécuter un grand lot de tâches, chacune sur son propre thread virtuel.

Réponds-y dans la leçon interactive

Récapitulatif

Vous savez maintenant comment créer des threads virtuels :

Thread.ofVirtual().start(...) et .unstarted(...)
Thread.startVirtualThread(...) en une seule instruction
.factory() pour obtenir une ThreadFactory réutilisable
Executors.newVirtualThreadPerTaskExecutor() avec la gestion automatique des ressources

Ensuite : choisir entre les threads de plateforme et les threads virtuels.

Gratuit pour commencer

Apprends Java avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 104
Leçons: 374

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Créer des threads virtuels » est-elle gratuite ?

Oui — le texte complet de « Créer des 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 « Créer des threads virtuels » ?

Thread.ofVirtual et exécuteurs 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 2 sur 4.

Combien de temps prend la leçon « Créer des 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