Java 21 LTS: Virtuelle Threads sind da

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- Java 21 ist am 19. September 2023 erschienen und ein LTS-Release.
- Virtuelle Threads (JEP 444) sind final: Thread pro Anfrage ohne die Kosten von Betriebssystem-Threads.
- Ebenfalls final: Record Patterns (JEP 440), Pattern Matching für switch (JEP 441) und Sequenced Collections (JEP 431).
- Weiter in der Vorschau: String Templates, Unnamed Patterns, Unnamed Classes, Structured Concurrency und Scoped Values.
- Pinning bei
synchronizedbleibt ein Thema; Spring Boot 3.2 mit Unterstützung für virtuelle Threads ist für November angekündigt.
Vor einem knappen Jahr habe ich hier geschrieben, dass ich vorbereitet sein will, wenn die virtuellen Threads als fertiges Feature kommen. Jetzt ist es so weit. Java 21 ist seit dem 19. September verfügbar, und weil es das nächste LTS nach Java 17 ist, wird dieses Release für sehr viele Teams der Punkt sein, an dem sie sich ernsthaft mit dem Thema beschäftigen. Ich habe mir angesehen, was drinsteckt und was davon im Alltag zählt. Dass es diesmal nicht nur um ein einzelnes Schlagwort geht, ist angenehm: Neben Loom ist ein ganzer Strang an Sprachverbesserungen zu Ende gegangen, den man seit Java 16 Schritt für Schritt verfolgen konnte. Wer damals mitgelesen hat, bekommt jetzt die Auflösung, und wer eine Weile ausgesetzt hat, muss sich nur an wenigen Stellen neu orientieren.
Ein LTS mit Gewicht
Zwischen 17 und 21 liegen vier Releases, und das merkt man. Wer auf LTS-Versionen setzt, bekommt das alles auf einmal. Deshalb lohnt sich ein genauer Blick, auch auf die kleinen Dinge, die in den Zwischenversionen untergegangen sind.
Die Feature-Liste ist lang. Final geworden sind unter anderem:
- Virtual Threads (JEP 444)
- Record Patterns (JEP 440)
- Pattern Matching für switch (JEP 441)
- Sequenced Collections (JEP 431)
- Generational ZGC (JEP 439)
- Key Encapsulation Mechanism API (JEP 452)
Dazu kommen Warnhinweise für die Zukunft: Der Windows-32-Bit-x86-Port gilt als deprecated (JEP 449), und das dynamische Laden von Agents in eine laufende JVM löst künftig eine Warnung aus (JEP 451). Letzteres dürfte vor allem Entwicklerwerkzeuge und Profiler betreffen.
Virtuelle Threads, jetzt ohne Preview
Das Prinzip kennt man aus meinem Artikel zu Java 19. Ein virtueller Thread ist ein leichtgewichtiger Thread, den die JVM verwaltet. Er wird auf wenige Plattform-Threads gemountet, und wenn er auf etwas wartet, etwa eine Netzwerkantwort, wird er geparkt. Der Code bleibt blockierend und linear, die Skalierung kommt aus der Laufzeit.
Der Einstieg sieht heute so aus:
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10_000; i++) {
executor.submit(() -> {
Thread.sleep(Duration.ofSeconds(1));
return null;
});
}
}Kein --enable-preview, keine Sonderbehandlung. Der try-Block endet erst, wenn alle Aufgaben durch sind. Einzelne Threads erzeugt man mit Thread.ofVirtual().start(...) oder Thread.startVirtualThread(...).
Was sich nicht geändert hat, ist die Faustregel: Virtuelle Threads nicht poolen. Sie sind billig genug, dass man pro Aufgabe einen neuen anlegt. Wer die Zahl gleichzeitiger Zugriffe auf eine knappe Ressource begrenzen will, nimmt einen Semaphor oder einen Connection-Pool.
Und ein Dämpfer, den ich schon bei der Vorschau erwähnt habe: Virtuelle Threads helfen beim Warten, nicht beim Rechnen. Bei CPU-lastigem Code bringen sie nichts.
Das Pinning-Problem bleibt
Die Stolperstelle, über die ich am meisten nachdenke, ist das Pinning. Blockiert ein virtueller Thread innerhalb eines synchronized-Blocks oder in einem nativen Aufruf, hängt er am Carrier fest und blockiert damit einen der wenigen Plattform-Threads. Gelegentlich ist das egal. Häufig und über lange Zeit kann es genau die Skalierung auffressen, die man sich erhofft hatte.
Die Empfehlung lautet derzeit, bei langen blockierenden Abschnitten ReentrantLock statt synchronized zu verwenden. Das ist bei eigenem Code machbar, bei Bibliotheken nicht. Ich fürchte, dass wir in den nächsten Monaten einige Berichte lesen werden, in denen ein Treiber oder ein Framework an dieser Stelle bremst. Ob die JVM die Einschränkung später abbaut, weiß ich nicht, ich würde mich darauf nicht verlassen.
Zum Aufspüren gibt es Diagnosemöglichkeiten. Mit -Djdk.tracePinnedThreads lassen sich Stellen ausgeben, an denen ein Thread beim Blockieren gepinnt war. Das würde ich in einem Testlauf einschalten, bevor man irgendetwas umstellt.
Pattern Matching wird erwachsen
Der zweite Block, der mich stärker freut, als er klingt, ist das Pattern Matching. Record Patterns und Pattern Matching für switch sind final, und zusammen mit sealed Interfaces ergibt das einen Stil, der in Java lange gefehlt hat:
sealed interface Form permits Kreis, Rechteck {}
record Kreis(double radius) implements Form {}
record Rechteck(double breite, double hoehe) implements Form {}
static double flaeche(Form form) {
return switch (form) {
case Kreis k -> Math.PI * k.radius() * k.radius();
case Rechteck(double b, double h) -> b * h;
};
}Der Compiler weiß, dass Form nur diese zwei Fälle hat, deshalb braucht der switch keinen default. Kommt später eine dritte Variante hinzu, meldet er genau die Stellen, an denen sie fehlt. Beim Rechteck wird der Record gleich in seine Bestandteile zerlegt. Das ist der Teil, bei dem ich das Gefühl habe, dass Java ein Stück funktionaler geworden ist, ohne seinen Charakter zu verlieren.
Kleinere Verbesserungen und der Blick nach vorn
Sequenced Collections klingt nach Theorie, löst aber ein altbekanntes Ärgernis. Das erste oder letzte Element einer Liste bekam man bisher auf verschiedenen Wegen, je nach Collection-Typ. Jetzt gibt es dafür getFirst(), getLast() und reversed(), einheitlich für Listen, LinkedHashSet und Co. Eine Kleinigkeit, die ich sofort benutzen werde.
Die Generational ZGC erweitert den Garbage Collector um eine Generationenaufteilung. Ob das für das eigene Projekt einen Unterschied macht, muss man messen, ich würde keine Versprechen abgeben.
Dann gibt es das, was noch im Preview-Status ist:
- String Templates (JEP 430)
- Unnamed Patterns and Variables (JEP 443), mit dem Unterstrich
_ - Unnamed Classes and Instance Main Methods (JEP 445), gedacht für den Einstieg in die Sprache
- Structured Concurrency (JEP 453)
- Scoped Values (JEP 446)
Structured Concurrency und Scoped Values sind für mich die logische Ergänzung zu den virtuellen Threads: das eine für klare Strukturen bei parallelen Aufgaben, das andere als Alternative zu ThreadLocal, das bei sehr vielen Threads ohnehin Probleme macht. Beides würde ich beobachten, aber noch nicht in Produktivcode einbauen.
Frameworks und Praxis
Ein LTS-Release ändert nichts, solange Frameworks nicht mitziehen. Spring Boot 3.2 soll nach Ankündigung im November erscheinen und virtuelle Threads unterstützen. Das ist bislang eine Ankündigung, und ich möchte erst sehen, wie sich das in realen Anwendungen verhält. Interessant wird, ob das Thema Pinning bei verbreiteten Bibliotheken hochkommt.
Mein Plan ist unspektakulär. Ein Testprojekt auf Java 21 umstellen, die Abhängigkeiten prüfen, einen kleinen Dienst mit dem virtuellen Executor laufen lassen und beobachten, wo es hakt. Erst danach würde ich über produktive Dienste nachdenken. Wer von 17 kommt, sollte außerdem die Liste der entfernten und veralteten Dinge durchgehen, sie ist nicht lang, aber sie enthält Überraschungen.
Hat jemand von euch schon Erfahrung mit virtuellen Threads in einem echten Dienst gesammelt? Mich würde besonders interessieren, ob das Pinning in der Praxis ein Problem war oder eher ein Randthema.
Beitragsbild: Foto Garnrollen von W.carter, CC BY-SA 4.0 (via Wikimedia Commons; zugeschnitten auf 16:9).
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.