~/blog/2022/10/java-19-virtuelle-threads-als-vors.md

Java 19: Virtuelle Threads als Vorschau

6 min
Beitragsbild: Java 19: Virtuelle Threads als Vorschau

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • Java 19 ist seit dem 20. September 2022 verfügbar, ist aber kein LTS-Release; das nächste LTS soll Java 21 im September 2023 sein.
  • Virtuelle Threads (JEP 425, Project Loom) sind eine Preview: leichtgewichtig, auf wenige Plattform-Threads gemountet, blockierende Aufrufe parken sie.
  • Ziel ist der einfache „Thread pro Anfrage“-Stil statt reaktiver Programmierung.
  • Stolperstellen: Pinning bei synchronized und nativen Aufrufen, viele ThreadLocals, kein Gewinn bei CPU-lastigem Code.
  • Außerdem in der Vorschau oder im Incubator: Structured Concurrency, Record Patterns, Pattern Matching für switch, Foreign Function & Memory API und Vector API.

Ich habe in den letzten Jahren ziemlich viel reaktiven Code gelesen und ein bisschen geschrieben. Er funktioniert, er skaliert, und wenn man ihn zwei Wochen nicht angesehen hat, versteht man ihn nicht mehr. Stacktraces, die nichts über die eigene Anwendung verraten, Operatorketten, in denen ein einzelner blockierender Aufruf alles ausbremst. Wenn ich ehrlich bin, war mein Hauptgrund, Project Loom zu verfolgen, der Wunsch nach einem Ausweg aus genau dieser Lage.

Mit Java 19, erschienen am 20. September, ist Loom zum ersten Mal in einem Release angekommen, wenn auch als Vorschau. Ich habe ein paar Tage damit herumprobiert.

Das Release im Überblick

Java 19 ist kein LTS-Release. Die letzte Version mit langem Support ist 17, die nächste soll Java 21 im September 2023 werden. Wer in Produktion auf LTS setzt, muss also nichts tun, außer neugierig sein. Trotzdem steckt einiges drin, vor allem Dinge, die sich noch im Reifen befinden:

  • Virtual Threads (JEP 425) als Preview
  • Structured Concurrency (JEP 428) als Incubator-Modul
  • Record Patterns (JEP 405) als Preview
  • Pattern Matching für switch (JEP 427), nun in der dritten Preview
  • Foreign Function & Memory API (JEP 424) als Preview
  • Vector API (JEP 426) im vierten Incubator
  • Linux/RISC-V-Port (JEP 422)

Viele Previews hintereinander sind eher ein gutes Zeichen. Die Sprache lässt sich Zeit, bevor sie etwas festschreibt, und das Feedback fließt tatsächlich ein, man sieht es an den Änderungen von Version zu Version. Für die virtuellen Threads halte ich diese Vorsicht für angemessen, denn sie rühren an etwas Grundsätzliches.

Was virtuelle Threads sind

Ein klassischer Java-Thread ist ein dünner Wrapper um einen Betriebssystem-Thread. Der ist teuer: Er reserviert Stack-Speicher, und das Betriebssystem muss ihn verwalten. Ein paar tausend davon sind machbar, hunderttausende nicht. Deshalb gibt es Thread-Pools, und deshalb ist der naive Stil „ein Thread pro Anfrage“ an seine Grenzen gestoßen. Als Ausweg entstanden asynchrone und reaktive Modelle, die mit wenigen Threads sehr viele Anfragen bedienen, aber den Code in Callbacks und Operatorketten zerlegen.

Virtuelle Threads drehen das um. Es sind leichtgewichtige Threads, die von der JVM verwaltet werden. Sie laufen nicht fest auf einem Betriebssystem-Thread, sondern werden auf wenige Plattform-Threads gemountet, die dann Carrier heißen. Ruft ein virtueller Thread einen blockierenden Vorgang auf, etwa Warten auf Netzwerk oder sleep, wird er geparkt, und der Carrier kann sich um einen anderen kümmern. Wenn das Ergebnis da ist, wird der virtuelle Thread wieder aufgeweckt. Der Code bleibt einfacher, linearer Code, und die Skalierung kommt von der Laufzeit.

Das ist der eigentliche Reiz: Man schreibt wieder, was man hinschreiben würde, wenn Threads billig wären.

Ausprobieren

Zum Ausprobieren braucht es die Preview-Schalter. Beim Kompilieren --enable-preview --release 19, beim Starten --enable-preview. Der einfachste Weg zu einem virtuellen Thread:

Thread t = Thread.ofVirtual().name("demo").start(() -> {
    System.out.println("Hallo aus " + Thread.currentThread());
});
t.join();

Interessanter ist der Executor, der pro Aufgabe einen neuen virtuellen Thread startet:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return null;
        });
    }
} // close() wartet, bis alle Aufgaben fertig sind

Zehntausend Threads, die jeweils eine Sekunde schlafen: Mit Plattform-Threads wäre das eine Zumutung, hier läuft es zügig durch. Neu in 19 ist übrigens, dass ExecutorService per try-with-resources geschlossen werden kann. Das ist eine kleine Änderung, die ich mir schon lange gewünscht habe.

Was man dabei nicht tun sollte, ist, virtuelle Threads in einen Pool zu stecken. Sie sind billig genug, dass man für jede Aufgabe einen neuen erzeugt. Ein Pool für virtuelle Threads ist also sinnlos, und er würde genau das einführen, was man loswerden wollte: eine künstliche Obergrenze.

Wo es hakt

Ich würde vor zu viel Euphorie warnen, denn es gibt Stolperstellen, die in der Vorschau schon bekannt sind.

Pinning. In bestimmten Situationen kann ein virtueller Thread nicht vom Carrier abgehängt werden. Das passiert in einem synchronized-Block und bei nativen Aufrufen. Blockiert der Thread dort, blockiert er auch den Carrier. Ein gelegentliches Pinning ist harmlos, ein häufiges bremst. Wo es möglich ist, kann man synchronized durch ReentrantLock ersetzen. Ich bin gespannt, wie sich das in der Praxis entwickelt und ob die JVM diese Einschränkung später abbaut.

ThreadLocals. Wer pro Thread einen Cache oder einen teuren Kontext in einem ThreadLocal ablegt, hat bei hunderttausend Threads plötzlich hunderttausend Kopien. Das funktioniert technisch, kann aber schnell zu viel Speicher fressen. Hier lohnt ein Blick in Code und Bibliotheken.

CPU-lastiger Code. Virtuelle Threads helfen beim Warten, nicht beim Rechnen. Wer Bilder skaliert oder Hashes berechnet, gewinnt nichts, weil am Ende ohnehin die Zahl der Prozessorkerne zählt.

Und die Faustregel von oben noch einmal: keine Pools, keine knappen Ressourcen über Threads regulieren. Wenn man etwa die Zahl gleichzeitiger Datenbankzugriffe begrenzen will, gehört das in einen Semaphor oder einen Connection-Pool, nicht in die Thread-Zahl.

Structured Concurrency und der Rest

Mit den virtuellen Threads kommt im Incubator die Structured Concurrency. Die Idee: Aufgaben, die gemeinsam gestartet werden, sollen auch gemeinsam enden, mit klarer Fehlerbehandlung und Abbruch. Das ähnelt dem, was strukturierte Programmierung einst mit goto gemacht hat, nur eben für Nebenläufigkeit. Ich habe es nur kurz angesehen, es ist ein Incubator, die API wird sich ändern.

Der Rest ist eher Beiwerk, aber nicht uninteressant. Record Patterns zerlegen Records direkt in instanceof und switch, die Pattern-Matching-Reihe wächst also weiter. Die Foreign Function & Memory API soll JNI auf lange Sicht ablösen. Und die Vector API ist inzwischen im vierten Incubator, was zeigt, wie sehr sie von Valhalla abhängt, das noch nicht fertig ist.

Was das für Spring und reaktive Stacks heißen könnte

Spannend wird die Frage, was das für reaktive Frameworks bedeutet. Wenn blockierender Code billig wird, verliert der reaktive Stil einen Teil seiner Begründung, zumindest dort, wo er nur wegen der Skalierung gewählt wurde. Für Streaming, Backpressure und ereignisgetriebene Datenflüsse bleibt er weiterhin eine sinnvolle Wahl. Wie die großen Frameworks reagieren, ist aus meiner Sicht offen. Ich vermute, dass Servlet-basierte Stacks relativ einfach von virtuellen Threads profitieren könnten, weil sie ohnehin pro Anfrage einen Thread nutzen. Mehr als eine Vermutung ist das nicht.

Ich werde vorerst nichts umbauen. Bis Java 21 als LTS erscheint, bleibt Zeit, in einem Nebenprojekt auszuprobieren, wie sich der Stil anfühlt und welche Bibliotheken mit Pinning Probleme machen. Wenn die Preview dann als fertiges Feature erscheint, will ich vorbereitet sein.

Habt ihr virtuelle Threads schon getestet? Ich bin neugierig, ob jemand einen Fall gefunden hat, in dem sie tatsächlich spürbar etwas verändern.

Beitragsbild: Foto Weberin am Webstuhl, Lijiang von CEphoto, Uwe Aranas, CC BY-SA 3.0 (via Wikimedia Commons; zugeschnitten auf 16:9).

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.