Java Academy · Lektion

Plattform- vs. virtuelle Threads

Wann welcher Ansatz geeignet ist

Plattform- vs. virtuelle Threads ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Zwei Arten von Threads

Java verfügt jetzt über zwei Thread-Arten. Plattform-Threads sind die klassischen Wrapper um Betriebssystem-Threads. Virtuelle Threads sind leichtgewichtig und werden von der JVM verwaltet.

Zu wissen, wann Sie welche Art einsetzen sollten, ist der Kern skalierbarer nebenläufiger Java-Anwendungen.

Einen Plattform-Thread erstellen

Sie erstellen einen Plattform-Thread mit Thread.ofPlatform(), dem Gegenstück zu 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();
    }
}

Kostenvergleich

Plattform-Threads sind schwergewichtig:

Jeweils etwa 1 MB reservierter Stack
Langsam zu erstellen
Auf wenige Tausend begrenzt

Virtuelle Threads sind kostengünstig: kleiner initialer Stack, schnelle Erstellung, Millionen sind möglich.

I/O-gebundene Arbeit

Wenn Ihre Aufgabe die meiste Zeit damit verbringt, auf Netzwerk, Festplatte oder eine Datenbank zu warten, bieten virtuelle Threads große Vorteile.

Während ein virtueller Thread blockiert, wird sein Träger für andere Aufgaben freigegeben. So können einige wenige Betriebssystem-Threads Tausende von Anfragen bedienen.

CPU-gebundene Arbeit

Bei reinen Berechnungen, die niemals blockieren, bieten virtuelle Threads keinen Geschwindigkeitsvorteil. Sie sind durch die Anzahl der Kerne begrenzt.

Hier ist ein fester Pool, dessen Größe der Anzahl der Prozessoren entspricht, das richtige Werkzeug.

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

Blockieren simulieren

Dieses Snippet zeigt viele virtuelle Threads, die gleichzeitig schlafen – als Ersatz für blockierende I/O. Stellen Sie sich vor, 10.000 Plattform-Threads würden dasselbe tun.

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

Daemon-Status

Virtuelle Threads sind immer Daemon-Threads und können nicht in Nicht-Daemon-Threads umgewandelt werden. Plattform-Threads übernehmen standardmäßig den Daemon-Status ihres Erstellers, können aber explizit konfiguriert werden.

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äten werden ignoriert

Virtuelle Threads melden immer eine Priorität von NORM_PRIORITY; das Setzen der Priorität hat keine Wirkung. Die Planung übernimmt die JVM, nicht der Scheduler des Betriebssystems.

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

Entscheidungshilfe

Eine praktische Faustregel:

Viele Aufgaben, die auf I/O warten? Verwenden Sie virtuelle Threads.
Aufwendige Berechnungen, die durch die CPU begrenzt sind? Verwenden Sie einen festen Pool von Plattform-Threads.
Benötigen Sie Optimierungen auf Betriebssystemebene für Threads, etwa Priorität oder Prozessorbindung? Verwenden Sie Plattform-Threads.

Sie können koexistieren

Sie müssen sich nicht für das gesamte Programm für eine Variante entscheiden. Eine typische Anwendung verwendet virtuelle Threads für die Verarbeitung von Anfragen und einen kleinen Pool von Plattform-Threads für CPU-intensive Abschnitte.

Beide verwenden dieselbe Thread-API, daher lassen sie sich nahtlos kombinieren.

Tipp zur Migration

Beim Umstellen eines I/O-intensiven Dienstes besteht die kleinste Änderung darin, den Executor auszutauschen: Ersetzen Sie einen festen oder zwischengespeicherten Pool durch newVirtualThreadPerTaskExecutor().

Achten Sie dabei auf Pinning und den übermäßigen Einsatz von ThreadLocal – beides wird in der nächsten Lektion behandelt.

Kurze Überprüfung

Wählen Sie die Arbeitslast aus, bei der virtuelle Threads den deutlichsten Vorteil bieten.

Zusammenfassung

Sie haben die beiden Thread-Modelle verglichen:

Plattform-Threads: schwergewichtig, vom Betriebssystem unterstützt, am besten für CPU-gebundene Arbeit und Optimierungen auf Betriebssystemebene
Virtuelle Threads: kostengünstig, von der JVM verwaltet, immer Daemon-Threads, am besten für I/O-gebundene Nebenläufigkeit
Sie können koexistieren und verwenden dieselbe API

Als Nächstes geht es um die Tücken von Pinning und ThreadLocals.

Häufig gestellte Fragen

Ist die Lektion „Plattform- vs. virtuelle Threads“ kostenlos?

Ja — der vollständige Text von „Plattform- vs. 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 „Plattform- vs. virtuelle Threads“?

Wann welcher Ansatz geeignet ist 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 3 von 4.

Wie lange dauert die Lektion „Plattform- vs. 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