~/blog/2024/01/spring-boot-3-2-virtuelle-threads.md

Spring Boot 3.2: Virtuelle Threads, RestClient und JdbcClient

6 min
Beitragsbild: Spring Boot 3.2: Virtuelle Threads, RestClient und JdbcClient

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • Spring Boot 3.2 (seit 23. November 2023, mit Spring Framework 6.1) schaltet virtuelle Threads per spring.threads.virtual.enabled=true ein, braucht dafür aber Java 21.
  • Tomcat, Jetty, @Async und das Scheduling nutzen dann virtuelle Threads; Pinning bei synchronized (etwa in JDBC-Treibern) kann den Gewinn aufzehren.
  • RestClient ist ein synchroner, fluenter HTTP-Client als Alternative zum RestTemplate, JdbcClient bringt eine fluente API für einfache SQL-Abfragen.
  • Außerdem neu: erste Unterstützung für CRaC (Checkpoint/Restore), Jetty 12 und das Neuladen von SSL-Bundles.
  • Mein Fazit: ein angenehmes Release, aber virtuelle Threads erst messen, dann einschalten.

Im Oktober habe ich über Java 21 geschrieben, und einer der Punkte war damals, dass virtuelle Threads endlich fertig sind. Fertig im Sinne der Sprache, wohlgemerkt. Ob das Ökosystem nachzieht, ist eine andere Frage. Spring Boot 3.2 ist seit dem 23. November draußen, zusammen mit Spring Framework 6.1, und es ist das erste Release, das die Sache ernsthaft anfasst. Ich habe es in den letzten Wochen an ein paar kleineren Anwendungen ausprobiert und schreibe auf, was mir aufgefallen ist.

Virtuelle Threads per Schalter

Der Einstieg ist fast peinlich einfach. Man braucht Java 21 und eine Zeile in der Konfiguration:

spring.threads.virtual.enabled=true

Mehr ist es nicht. Spring Boot stellt dann den eingebetteten Webserver (Tomcat oder Jetty) so um, dass Anfragen auf virtuellen Threads laufen. Auch @Async-Methoden, das Scheduling und einige weitere Stellen im Framework greifen darauf zurück. Der Code der Anwendung bleibt, wie er ist, mit blockierenden Aufrufen, normalen Stacktraces und dem vertrauten Debugging. Genau das war ja das Versprechen: Man schreibt weiter einfachen, sequentiellen Code und bekommt trotzdem viele gleichzeitige Verbindungen, ohne auf reaktive Frameworks umzusteigen.

Ich finde diese Herangehensweise sympathisch. Sie nimmt den Druck aus der Debatte „blockierend gegen reaktiv“, in der man sich lange zwischen zwei unbequemen Optionen entscheiden musste. Wer eine klassische Spring-MVC-Anwendung hat, die den größten Teil ihrer Zeit auf Datenbank und andere Dienste wartet, hat mit einem Schalter eine Möglichkeit, die Wartezeit billiger zu machen.

Was der Schalter nicht kann

Hier wird es allerdings differenzierter. Virtuelle Threads helfen bei Wartezeit, nicht bei Rechenzeit. Eine Anwendung, die CPU-lastig arbeitet, wird durch mehr Threads nicht schneller. Und auch das Wartende muss mitspielen.

Das bekannteste Stichwort ist das Pinning. Ein virtueller Thread läuft auf einem Trägerthread. Wenn er blockiert, wird er normalerweise abgehängt und der Träger frei für andere Arbeit. Geschieht das Blockieren aber innerhalb eines synchronized-Blocks, bleibt der virtuelle Thread am Träger „kleben“, und der Träger ist blockiert. Das passiert nicht nur in eigenem Code, sondern auch in Bibliotheken. JDBC-Treiber sind ein naheliegender Verdachtskandidat, weil dort traditionell viel synchronisiert wird. Ob und wie stark das bei einem konkreten Treiber zutrifft, kann ich nicht allgemein sagen. Das muss man für seinen Treiber in der eingesetzten Version nachlesen und messen.

Hilfreich ist die Systemeigenschaft -Djdk.tracePinnedThreads=full, die beim Pinning eine Ausgabe erzeugt. Dazu kommen die Java-Flight-Recorder-Ereignisse für gepinnte Threads. Ohne solche Messungen würde ich virtuelle Threads nicht in einer Produktionsumgebung einschalten, nur weil es ein Release-Highlight ist. Ein zweiter Punkt: Wer bisher die Größe seines Thread-Pools als eine Art natürliche Bremse benutzt hat, verliert diese Bremse. Plötzlich kommen mehr gleichzeitige Anfragen bei der Datenbank an, und deren Verbindungspool wird zum Engpass, den man bisher nicht sah. Das ist kein Fehler der virtuellen Threads, aber eine Verschiebung, die man einplanen sollte.

RestClient: der neue synchrone Client

Der Teil, der mir im Alltag am meisten bringt, ist der neue RestClient. Das RestTemplate ist seit Langem im Wartungsmodus, und wer keinen reaktiven WebClient einführen wollte, nur um eine API fluent aufzurufen, hatte keine gute Alternative. Jetzt gibt es eine:

RestClient client = RestClient.create("https://api.example.org");

Kunde kunde = client.get()
        .uri("/kunden/{id}", 42)
        .retrieve()
        .body(Kunde.class);

Das liest sich fast wie der WebClient, ist aber synchron und braucht nichts Reaktives. Für Voreinstellungen nimmt man den Builder:

RestClient client = RestClient.builder()
        .baseUrl("https://api.example.org")
        .defaultHeader("Accept", "application/json")
        .build();

Fehlerbehandlung läuft über onStatus, und wer die ganze Antwort samt Statuscode braucht, kann toEntity(...) verwenden. In Spring Boot gibt es einen vorkonfigurierten RestClient.Builder, sodass Nachrichtenkonverter und Ähnliches wie gewohnt eingebunden sind. Das RestTemplate verschwindet nicht, aber für neuen Code würde ich es nicht mehr nehmen. Bestehenden Code umzustellen ist eine Frage der Gelegenheit, nicht der Dringlichkeit.

JdbcClient: kleiner Komfortgewinn

Der JdbcClient ist eine fluente Schicht über dem JdbcTemplate und passt gut zu den Fällen, in denen JPA zu viel wäre:

List<Kunde> kunden = jdbcClient
        .sql("select id, name from kunde where ort = :ort")
        .param("ort", "Berlin")
        .query(Kunde.class)
        .list();

Benannte Parameter, einfache Abbildung auf Klassen oder Records, optional() und single() für Einzelergebnisse. Das ist keine Revolution, aber es nimmt viel Zeremonie aus kleinen Abfragen. Ich habe es für ein internes Werkzeug ausprobiert, das nur ein paar Tabellen lesen muss, und dort war es angenehm, weil kein Mapping-Framework nötig war. Für komplexe Domänenmodelle wird man bei JPA oder jOOQ bleiben, das ist kein Konkurrent, sondern ein Werkzeug für die Lücke dazwischen.

Noch mehr im Paket

Ein paar Dinge, die nicht im Rampenlicht stehen, aber erwähnenswert sind. Spring Framework 6.1 hat eine erste Unterstützung für CRaC, also Checkpoint und Restore: Man startet die Anwendung, wärmt sie auf, speichert einen Schnappschuss des Prozesses und startet später aus diesem Zustand. Das zielt auf sehr schnelle Starts, ohne den Weg über Native Images zu gehen. Ich habe es nicht praktisch eingesetzt und halte mich deshalb zurück, es ist außerdem abhängig von einer JVM, die das unterstützt. Auf meiner Beobachtungsliste steht es trotzdem.

Dazu kommt Jetty 12, und für TLS die Möglichkeit, SSL-Bundles neu zu laden, wenn sich Zertifikate ändern. Der zweite Punkt klingt trocken, löst aber ein reales Betriebsproblem: Zertifikate laufen ab, und ein Neustart nur dafür ist lästig.

Wie ich vorgehen würde

Für ein bestehendes Projekt würde ich es so angehen:

  1. Zuerst auf Java 21 und Spring Boot 3.2 umstellen, ohne virtuelle Threads. Das ist ein eigener Schritt mit eigenen möglichen Problemen.
  2. Dann einen Lasttest als Ausgangspunkt, bevor irgendetwas umgestellt wird.
  3. Danach den Schalter setzen und noch einmal messen, mit aktivierter Pinning-Ausgabe.
  4. Beobachten, ob Datenbank-Verbindungspool oder nachgelagerte Dienste jetzt zum Flaschenhals werden.

Zu jedem dieser Schritte passt dasselbe Prinzip: nicht glauben, sondern ansehen. Gerade bei Nebenläufigkeit ist die Intuition ein schlechter Ratgeber.

Einordnung

Spring Boot 3.2 ist für mich ein Release, das weniger durch ein einzelnes großes Feature auffällt als durch viele Stellen, an denen Alltagsarbeit leichter wird. Der RestClient fehlte, der JdbcClient war überfällig, und die virtuellen Threads geben dem klassischen, blockierenden Stil eine zweite Chance. Das Bild, das sich bei mir festsetzt: Das Framework folgt der Plattform schneller als früher, und die Plattform liefert wieder Dinge, die man tatsächlich verwenden will.

Trotzdem bleibe ich vorsichtig. Ein Schalter, der alles verändert, ist praktisch, aber er verlockt dazu, die Folgen zu übersehen. Wer ihn umlegt, sollte vorher wissen, wie die Anwendung sich verhält, und danach nachsehen, ob sie das noch tut. Habt ihr virtuelle Threads schon produktiv im Einsatz? Mich würde besonders interessieren, ob ihr Pinning mit eurem Datenbanktreiber beobachtet habt.

Beitragsbild: Spring Framework Logo 2018 (Ersatz; Spring-Security-Logo gibt es nicht, neueres Logo) von Pivotal Software, Apache License 2.0 (via Wikimedia Commons; unverändert auf eigenem Hintergrund). Die Marke gehört ihrem Inhaber.

$ whoami
Christian Ackermann

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