Java Academy · Lektion

Was sind virtuelle Threads

Leichtgewichtige Threads in Java 21

Was sind virtuelle Threads ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen bei virtuellen Threads

Virtuelle Threads wurden mit Java 21 als endgültiges Feature eingeführt (JEP 444). Sie sind leichtgewichtige Threads, die von der JVM und nicht vom Betriebssystem verwaltet werden.

Das Ziel ist einfach: Sie können übersichtlichen Code mit thread-per-request schreiben und trotzdem auf Millionen gleichzeitig ausgeführter Aufgaben skalieren.

Das alte Problem

Ein herkömmlicher Plattform-Thread entspricht eins zu eins einem Betriebssystem-Thread. Jeder benötigt etwa ein Megabyte Stack und ist teuer zu erstellen.

Daher können Sie nur einige Tausend gleichzeitig ausführen. Blockierende I/O belegt während des Wartens einen gesamten Betriebssystem-Thread.

Wie sich virtuelle Threads unterscheiden

Ein virtueller Thread besitzt keinen Betriebssystem-Thread. Viele virtuelle Threads werden auf einen kleinen Pool von Carrier-Plattform-Threads gemultiplext.

Günstig zu erstellen (Tausende pro Millisekunde)
Sehr geringer Speicherbedarf
Blockieren parkt den virtuellen Thread einfach und gibt den Carrier frei

Mounten und Unmounten

Wenn ein virtueller Thread ausgeführt wird, ist er auf einen Carrier-Thread gemountet. Wenn er auf eine blockierende Operation trifft, wird er unmountet und gibt den Carrier frei, sodass andere Arbeit fortgesetzt werden kann.

Dieses Parken und Fortsetzen geschieht automatisch. Ihr Code liest sich wie gewöhnlicher blockierender Code.

Ein erster virtueller Thread

Hier ist das einfachste mögliche Beispiel. Thread.ofVirtual().start(...) startet einen virtuellen Thread, und join() wartet auf ihn.

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

Bestätigen, dass er virtuell ist

Jeder Thread stellt isVirtual() bereit. Damit können Sie überprüfen, auf welcher Art von Thread Ihr Code ausgeführt wird.

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

Auf viele Aufgaben skalieren

Da virtuelle Threads kostengünstig sind, ist es völlig normal, Zehntausende davon zu starten. Hier starten wir 10.000 virtuelle Threads.

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

Virtuelle Threads benennen

Sie können einen virtuellen Thread zur einfacheren Fehlersuche mithilfe des Builders benennen, bevor Sie ihn starten.

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

Gleiche API, neue Engine

Virtuelle Threads implementieren exakt dieselbe Thread-API, die Sie bereits kennen. Sie verwenden weiterhin start, join, sleep und interrupt.

Das bedeutet, dass vorhandene Bibliotheken, die auf Thread und Runnable basieren, ohne Änderungen funktionieren.

Wann Sie sie verwenden

Virtuelle Threads spielen ihre Stärken bei I/O-gebundenen Arbeitslasten aus: Webservern, Datenbankaufrufen und Anfragen an entfernte APIs.

Bei CPU-gebundenen Berechnungen sind sie hingegen nicht schneller. Dort sind Sie weiterhin durch die Anzahl Ihrer Kerne begrenzt.

Kein Pool

Eine wichtige Umstellung der Denkweise: Sie bilden keinen Pool virtueller Threads. Erstellen Sie für jede Aufgabe einen neuen Thread und lassen Sie ihn enden, sobald die Aufgabe abgeschlossen ist.

Pooling dient dazu, teure Ressourcen wiederzuverwenden. Virtuelle Threads sind kostengünstig, daher ist ihr Pooling ein Anti-Pattern.

Kurze Überprüfung

Testen Sie Ihr Verständnis virtueller Threads.

Zusammenfassung

Sie haben gelernt, was virtuelle Threads sind und warum sie wichtig sind:

Leichtgewichtig, von der JVM verwaltet und mit Java 21 eingeführt
Durch Mounten und Unmounten auf Träger-Threads gemultiplext
Ideal für nebenläufige I/O-gebundene Arbeitslasten
Dieselbe Thread-API, aber pro Aufgabe statt in einem Pool erstellt

Als Nächstes lernen Sie die verschiedenen Möglichkeiten kennen, sie zu erstellen.

Häufig gestellte Fragen

Ist die Lektion „Was sind virtuelle Threads“ kostenlos?

Ja — der vollständige Text von „Was sind virtuelle Threads“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Was sind virtuelle Threads“?

Leichtgewichtige Threads in Java 21 Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Was sind virtuelle Threads“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy