9. Asynchrone Programmierung
Das vorherige Kapitel hat Threads eingeführt: Wir können mehrere Codestücke „gleichzeitig“ ausführen, sie synchronisieren und Aufgaben über einen Executor ([ExecutorService]) einem Thread-Pool zuweisen. Dieses Kapitel behandelt ein verwandtes, aber eigenständiges Problem: wie man ein Programm schreibt, das viel wartet (auf die Festplatte, das Netzwerk oder eine Datenbank), ohne während dieser Wartezeiten Threads zu binden.
Java hat dafür keine Sprachschlüsselwörter (andere Sprachen wie C# oder JavaScript haben die Schlüsselwörter [async] und [await]). Es bietet zwei Lösungen an, die sich ergänzen und beide in diesem Kapitel vorgestellt werden:
- die Klasse [CompletableFuture<T>] (Java 8, seither erweitert) stellt eine laufende Operation dar, deren nachfolgende Schritte mithilfe von Callback-Methoden zusammengesetzt werden: „Wenn das Ergebnis bereit ist, tue dies, dann das“ ([thenApply], [thenCompose], [thenCombine], [allOf] …). Kein Thread wartet: Der Abschluss der Operation löst den nächsten Schritt aus;
- virtuelle Threads ( Java 21) erlauben es dagegen, blockierenden, sequenziellen Code zu schreiben, der sich von oben nach unten liest: Wartet ein virtueller Thread auf Ein-/Ausgabe, löst die JVM ihn von dem Systemthread, der ihn ausgeführt hat (seinem „Trägerthread“), und gibt diesen Thread für einen anderen virtuellen Thread frei. So sind Hunderttausende virtueller Threads auf nur wenigen Systemthreads möglich. Das ist die moderne Lösung von Java für das Problem, das andere Sprachen mit [async] / [await] lösen.
Diese Werkzeuge sind heute allgegenwärtig: Die folgenden Kapitel setzen sie ein, um auf Datenbanken zuzugreifen, TCP-Server zu schreiben, die jeden Client über einen virtuellen Thread bedienen, Web-Clients mit [java.net.http.HttpClient] und Webdienste mit Spring Boot.
Alle Beispiele dieses Kapitels sind kompakte Quelldateien ([Async01.java], [Async02.java] …), die mit [java AsyncNN.java] im Ordner [09-async] ausgeführt werden. Viele davon messen Ausführungszeiten mit [System.nanoTime()]: Die angezeigten Millisekunden variieren von Lauf zu Lauf und von Rechner zu Rechner (die Beispiele wurden auf einem Rechner mit zwei Prozessoren ausgeführt). Es kommt auf die Größenordnungen an: 1 Sekunde oder 10 Sekunden, 300 ms oder 0 ms.
9.1. Warum Asynchronität
9.1.1. Operationen, die warten
Ein Programm verrichtet zwei Arten von Arbeit:
- Rechenaufgaben, die den Prozessor beanspruchen: eine Liste sortieren, eine Steuer berechnen, einen Text analysieren;
- Ein-/Ausgabe (E/A), die im Wesentlichen im Warten auf ein Peripheriegerät besteht: eine Datei von der Festplatte lesen, eine Anfrage an einen Webserver senden und auf seine Antwort warten, eine SQL-Abfrage auf einem Datenbankserver ausführen.
Die Größenordnungen sind sehr unterschiedlich. Ein Prozessor führt einige Milliarden Anweisungen pro Sekunde aus. Ein Lesevorgang auf einer Festplatte (SSD) dauert etwa eine Zehntelmillisekunde; ein Hin- und Rückweg in einem lokalen Netzwerk dauert den Bruchteil einer Millisekunde; ein Hin- und Rückweg zu einem Server am anderen Ende des Landes dauert einige zehn Millisekunden; und eine etwas komplexere SQL-Abfrage kann mitunter mehrere Sekunden dauern. Während dieser Wartezeiten hätte der Prozessor Millionen von Anweisungen ausführen können.
Wenn ein Programm mit einer blockierenden Methode eine Zeile über eine Netzwerkverbindung liest, ist der Thread, der diesen Lesevorgang ausführt, blockiert: Er tut nichts, existiert aber weiterhin. Ein „klassischer“ Java-Thread – heute als „Plattform-Thread“ bezeichnet – ist ein Thread des Betriebssystems: Er belegt Speicher (seinen Stack, in der Größenordnung eines Megabytes), er ist dem System bekannt, und vor allem steht er nicht mehr für andere Aufgaben zur Verfügung. In einem kleinen Konsolenprogramm, das jeweils nur eine Sache tut, ist das kein Problem. In zwei Situationen wird es deutlich problematischer:
- in einem Server: Jeder Client, der von einem blockierten Thread bedient wird, bindet diesen Thread. Hat der Thread-Pool des Servers N Threads und führen alle N Threads eine blockierende Operation aus, bleibt für einen neuen Client kein Thread mehr verfügbar. Ein moderner Server bearbeitet Tausende gleichzeitiger Anfragen: Das ist möglich, weil seine Warteoperationen keine Systemthreads binden;
- in einer grafischen Benutzeroberfläche: Ein einziger Thread – der UI-Thread (der „Event Dispatch Thread“ von Swing, der „JavaFX Application Thread“) – bearbeitet Klicks und zeichnet Fenster neu. Wird er durch einen Download blockiert, friert das Fenster ein.
Asynchronität bedeutet, die E/A-Operation zu starten, den Systemthread freizugeben, solange sie läuft (die Hardware und das Betriebssystem brauchen ihn nicht, um Daten zu übertragen), und die Arbeit nach Abschluss der Operation fortzusetzen, gegebenenfalls auf einem anderen Systemthread:

- In [1]startet der Plattform-Thread T1 die E/A und bleibt blockiert, bis sie beendet ist;
- in [2]startet der virtuelle Thread V1 die E/A; die JVM löst ihn von seinem Trägerthread P1, der dann sofort andere virtuelle Threads ausführen kann. Wenn die E/A abgeschlossen ist, verbindet die JVM V1 wieder mit einem freien Trägerthread, P2 (der auch P1 sein könnte), und V1 setzt seine Ausführung unmittelbar nach der blockierenden Anweisung fort, als sei nichts geschehen.
Das Programm [Async01.java] misst den Unterschied bei 100 Operationen, die jeweils eine Sekunde warten (das Warten simuliert E/A). Es verwendet Anweisungen, die wir später in diesem Kapitel erklären ([Executors.newVirtualThreadPerTaskExecutor], [CompletableFuture]): Hier interessieren uns vor allem die Ergebnisse.
Ergebnisse:
Erläuterungen:
- Zeilen 12–22: die einfachste Lösung – ein Plattform-Thread pro Operation. [Thread.ofPlatform().start(task)] (Java 21) erzeugt und startet einen Thread, genau wie [new Thread(task).start()]. Jeder Thread führt [Thread.sleep(1000)] aus: Er ist eine Sekunde lang blockiert. Die 100 Wartevorgänge laufen gleichzeitig ab, und der gesamte Vorgang dauert genau eine Sekunde (Zeile 4 der Ergebnisse), jedoch um den Preis von 100 zusätzlichen Systemthreads: Die JVM hat 106 davon (Zeile 3). Bei 10.000 Operationen wären 10.000 Systemthreads erforderlich;
- Zeilen 24–32: Die Operationen werden einem Pool aus 10 Threads zugewiesen ([Executors.newFixedThreadPool(10)]), eine für Berechnungen vernünftige Größe. Hier rechnen diese Threads aber nicht – sie sind untätig. Die Operationen warten in Gruppen von 10 auf einen freien Thread, und der gesamte Vorgang dauert … zehn Sekunden (Zeile 6). Das nennt man „Thread-Pool-Starvation“, den häufigsten Fehler in Servern, die Thread-Pools mit blockierender E/A mischen. Die Methode [close()] eines Executors (Java 19), die beim Verlassen von [try] aufgerufen wird, lehnt neue Aufgaben ab und wartet, bis die übergebenen beendet sind;
- Zeilen 34–42: Ein virtueller Thread pro Operation. [Executors.newVirtualThreadPerTaskExecutor()] (Java 21) gibt einen Executor zurück, der für jede übergebene Aufgabe einen neuen virtuellen Thread erzeugt. Der Code der Aufgabe ist derselbe wie in Schritt 1: ein blockierendes [Thread.sleep(1000)]. Ein blockierter virtueller Thread bindet jedoch keinen Systemthread: Die JVM löst ihn von seinem Trägerthread. Die 100 Wartevorgänge dauern insgesamt eine Sekunde (Zeile 8), und die JVM zählt nur 10 Systemthreads (Zeile 7): ihre Dienst-Threads und die beiden Trägerthreads – einer pro Prozessor –, die die 100 virtuellen Threads ausgeführt haben. Die virtuellen Threads sind in dieser Zählung nicht enthalten: Sie sind Objekte der JVM, keine Systemthreads;
- Zeilen 44–52: dasselbe Warten ohne wartende Threads. [new CompletableFuture<Void>()] erzeugt eine „ausstehende“ Operation, und [completeOnTimeout(value, timeout, unit)] (Java 9) fordert an, dass sie nach Ablauf der Zeitspanne mit dem angegebenen Wert abgeschlossen wird. Ein einziger Timer der JVM verwaltet die 100 Zeitüberschreitungen. [CompletableFuture.allOf(...)] gibt eine Operation zurück, die abgeschlossen ist, wenn alle anderen beendet sind, und [join()] wartet auf ihr Ende. Der gesamte Vorgang dauert eine Sekunde (Zeile 10), mit nur einem zusätzlichen Thread gegenüber Schritt 3 – dem Timer-Thread (Zeile 9);
- Zeilen 55–62: [Thread.sleep] kann die geprüfte Ausnahme [InterruptedException] auslösen, wenn der Thread während des Schlafens unterbrochen wird (darauf gehen wir im Abschnitt über den Abbruch noch ein); die Methode [waitFor] fängt sie ab, damit die Lambdas in den Zeilen 16, 28 und 38 sie nicht behandeln müssen;
- Zeilen 64–71: [ManagementFactory.getThreadMXBean().getThreadCount()] gibt die Anzahl der lebenden Plattform-Threads der JVM zurück. Die Klasse [ManagementFactory] gehört zum Modul [java.management]: Eine kompakte Quelldatei importiert automatisch nur das Modul [java.base], daher der Import in Zeile 3.
Merken wir uns die Lehre: Um zu warten, darf man keine Systemthreads blockieren. Asynchronität macht E/A nicht schneller; sie ermöglicht es, eine große Anzahl von E/A-Operationen gleichzeitig mit wenigen Systemthreads zu bewältigen und dabei die von der Anwendung benötigten Threads verfügbar zu halten. Java bietet hierfür zwei Ansätze: [CompletableFuture] zu erzeugen (Schritt 4) oder gewöhnlichen blockierenden Code zu schreiben, der von virtuellen Threads ausgeführt wird (Schritt 3).
9.1.2. Mehrere aufeinanderfolgende Modelle
Java hat mehrere Möglichkeiten angeboten, Code zu schreiben, der wartet, ohne zu blockieren. Die älteren finden sich noch in bestehendem Code, daher ist es nützlich, sie zu erkennen.
Muster | Einführung | Prinzip |
[Future] und Runtimes | Java 5 (2004) | [ExecutorService.submit] weist einem Thread-Pool eine Aufgabe zu und gibt ein [Future<T>] zurück, das das kommende Ergebnis darstellt. Dieses Ergebnis lässt sich aber nur durch blockierendes Warten mit [get()] erhalten. |
Callback-Methoden von NIO.2 | Java 7 (2011) | Asynchrone Kanäle ([AsynchronousSocketChannel], [AsynchronousFileChannel]) starten eine Operation und erhalten ein Callback-Objekt ([CompletionHandler]), dessen Methode [completed] oder [failed] nach Abschluss der Operation von einem Thread aus einem Pool aufgerufen wird. |
[CompletableFuture] | Java 8 (2014) | ein [Future] , das Sie selbst abschließen können und dessen Ablauf aus Callback-Methoden zusammengesetzt wird ([thenApply], [thenCompose], [exceptionally] …); reaktive Streams [java.util.concurrent.Flow] (Java 9) sind eine Erweiterung davon für Wertfolgen. Reaktive Bibliotheken (Project Reactor, von Spring WebFlux verwendet, RxJava) beruhen auf denselben Konzepten. |
virtuelle Threads | Java 21 (2023) | gewöhnlicher blockierender Code, der von virtuellen Threads ausgeführt wird: Die JVM gibt den Systemthread während des Wartens frei. Das ist heute das empfohlene Modell für neue Anwendungen. |
strukturierte Nebenläufigkeit | Vorschau von Java 21 bis Java 25 | [StructuredTaskScope] organisiert eine Gruppe von Teilaufgaben, die von virtuellen Threads ausgeführt werden, als einen einzigen Codeblock, mit gemeinsamer Fehlerbehandlung und gemeinsamem Abbruch (siehe das Ende des Kapitels). |
Callback-Methoden haben einen Nachteil: Der Code wird zerstückelt. Was sich natürlich als „verbinden, dann lesen, dann anzeigen“ liest, wird zu einer Methode, die die Verbindung startet, einer Callback-Methode, die den Lesevorgang startet, und einer weiteren Callback-Methode, die das Ergebnis anzeigt; Variablen müssen zwischen diesen Methoden geteilt werden, Ausnahmen werden an verschiedenen Stellen abgefangen, und eine einfache Schleife („lesen, solange Daten vorhanden sind“) wird zu einer Callback-Methode, die sich rekursiv selbst aufruft. [CompletableFuture] macht diese Zerstückelung lesbarer, indem es die Schritte verkettet; virtuelle Threads lassen sie verschwinden: Asynchroner Code nimmt die Form synchronen Codes an, weil er tatsächlich synchroner Code ist.
Das Programm [Async02.java] implementiert denselben TCP-Client mit zwei extremen Ansätzen: zunächst mit den Callback-Methoden von NIO.2, dann mit blockierendem Code, der von einem virtuellen Thread ausgeführt wird. Es enthält außerdem einen kleinen Server, der von einem Thread betrieben wird und zwei Clients antwortet (die Netzwerkprogrammierung wird in Kapitel 12 ausführlich behandelt; vorerst genügt es zu wissen, dass ein Client sich mit dem Server verbindet und die Nachricht liest, die der Server ihm sendet).
Ergebnisse:
Erläuterungen:
- Zeilen 8–23: der Server. Er lauscht auf Port 27500 des lokalen Rechners ([InetAddress.getLoopbackAddress()], also 127.0.0.1), nimmt nacheinander zwei Verbindungen an und sendet jedem Client nach einer halben Sekunde eine Willkommensnachricht. Er wird von einem Plattform-Thread namens [server] ausgeführt. Die Form [try (listener)] (Java 9) schließt am Ende des Blocks den in Zeile 9 deklarierten [ServerSocket] ;
- Zeilen 26–32: Der Client schreibt mit Callback-Methoden:
- Zeile 27: Ein
*[AsynchronousSocketChannel]* ist einTCP-Kanal, dessen Operationen asynchron sind; - Zeile 29: [connect] startet die Verbindung und gibt sofort die Kontrolle zurück (Zeile 3 der Ergebnisse). Seine letzten beiden Parameter sind ein beliebiges Objekt, das die Callback-Methode erhält (hier der Kanal selbst), und das Callback-Objekt vom Typ [Connected];
- Zeile 32: Der Haupt-Thread hat nichts mehr zu tun. Damit das Programm nicht endet, bevor der Austausch abgeschlossen ist, wartet er auf ein Signal der letzten Callback-Methode: ein [CountDownLatch] , auf 1 initialisiert (Zeile 5), dessen Methode [await] den aufrufenden Thread blockiert, bis ein anderer Thread seine Methode [countDown] aufruft;
- Zeile 27: Ein
- Zeilen 50–64: Das Callback-Objekt der Verbindung implementiert die Schnittstelle [CompletionHandler<V, A>], wobei [V] der Ergebnistyp der Operation ist ([Void] bei einer Verbindung) und [A] der Typ des übergebenen Objekts. Seine Methode [completed] wird aufgerufen, wenn die Operation erfolgreich ist, und seine Methode [failed] wird aufgerufen, wenn sie fehlschlägt. Sobald die Verbindung steht, wird das Lesen mit [read] gestartet, wobei ein zweites Callback-Objekt vom Typ [Received] angegeben wird (Zeile 56);
- Zeilen 66–85: Das Callback-Objekt des Lesevorgangs erhält die Anzahl der gelesenen Bytes, zeigt die Nachricht an, schließt den Kanal und gibt den Haupt-Thread frei. Die Klassen [Connected] und [Received] sind innere Klassen der impliziten Klasse der kompakten Datei: Sie haben Zugriff auf deren Felder [buffer] und [end] sowie auf ihre Methode [display];
- die Ergebnisse zeigen, dass die Callback-Methoden von anderen Threads als dem Haupt-Thread ausgeführt werden (Threads aus dem Pool der JVM, der für asynchrone Kanäle vorgesehen ist, mit dem Namen [InnocuousThread-N]);
- Zeilen 34–46: derselbe Client, geschrieben mit einem gewöhnlichen [Socket] und blockierenden Operationen ([new Socket(...)] verbindet, [read] wartet auf Daten), ausgeführt von einem virtuellen Thread, der mit [Thread.ofVirtual().start(task)] (Java 21) erzeugt wird. Der Code liest sich wie synchroner Code von oben nach unten; die Variablen sind gewöhnliche lokale Variablen; Fehler werden von einem einzigen [try / catch] behandelt; es gibt keine Callback-Methoden oder Signale zu verwalten;
- Zeilen 87–92: Jeder Ausgabe wird der Thread vorangestellt, der sie ausführt. Für einen virtuellen Thread gibt [toString()] eine Beschreibung der Form [VirtualThread[#28]/runnable@ForkJoinPool-1-worker-1] zurück: die Nummer des virtuellen Threads, sein Zustand und sein aktueller Trägerthread. Die Zeilen 6 und 7 der Ergebnisse zeigen denselben virtuellen Thread Nr. 28, der zuerst von [worker-1] und dann von [worker-2] getragen wird: Während er auf die Antwort des Servers wartete, wurde er von seinem ersten Träger gelöst und anschließend an einen anderen gebunden.
Es ist nicht nötig, sich die Schnittstelle [CompletionHandler] zu merken. Wenn Sie eine API verwenden müssen, die nur dieses Modell anbietet, wandeln Sie sie in ein [CompletableFuture] um (das tun wir in [Async17.java]), oder verwenden Sie ihre blockierende Version auf einem virtuellen Thread.
9.2. Kommende Aufgaben: Future und CompletableFuture
Ein [Future<T>] (Schnittstelle des Pakets [java.util.concurrent], Java 5) ist ein Objekt, das das Ergebnis – vom Typ [T] – einer laufenden oder beendeten Operation darstellt. Wir sind ihm im vorherigen Kapitel begegnet: Es ist das, was die Methode [submit] eines Executors zurückgibt. Sie können es abfragen (ist es beendet? war es erfolgreich?), abbrechen ([cancel]) und auf sein Ergebnis warten ([get]), aber nicht mehr: Das Ergebnis lässt sich nur verwenden, indem man einen Thread blockiert, bis es verfügbar ist.
Die Klasse [CompletableFuture<T>] (Java 8) implementiert [Future<T>] und fügt zwei wesentliche Fähigkeiten hinzu:
- Sie können es selbst beenden, mit einem Ergebnis ([complete]) oder mit einer Ausnahme ([completeExceptionally]);
- Sie können daran eine Folgeoperation anhängen – eine Funktion, die ausgeführt wird, sobald das Ergebnis verfügbar ist ([thenApply], [thenAccept], [thenCompose] …) und die ein neues [CompletableFuture] erzeugt. So entstehen Operationsketten, ohne dass ein Thread warten muss. Diese Methoden werden von der Schnittstelle [CompletionStage<T>] deklariert, die [CompletableFuture] ebenfalls implementiert.
Ein [CompletableFuture] ist kein Thread. Er kann einen Vorgang darstellen, der von einem Thread eines Executors ausgeführt wird (wie bei den mit [supplyAsync] erzeugten), aber viele werden von keinem Thread ausgeführt: Der in Schritt 4 von [Async01.java] wird einfach nach einer Sekunde von einem Timer „abgeschlossen“, und der von [HttpClient.sendAsync] zurückgegebene wird abgeschlossen, wenn die Antwort des Servers eintrifft. Er ist ein Versprechen auf ein Ergebnis.
Das Programm [Async03.java] zeigt die wichtigsten Wege, ein [CompletableFuture] zu erzeugen, abzufragen und darauf zu warten:
Ergebnisse:
Erläuterungen:
- Zeilen 4–11: [CompletableFuture.supplyAsync(supplier)] übergibt einem Executor eine Funktion ohne Parameter ([Supplier<T>]) und gibt sofort ein [CompletableFuture<T>] zurück, das ihre Ausführung darstellt. Die Funktion gibt einen [long] zurück, wir erhalten also ein [CompletableFuture<Long>]. Ohne expliziten Executor führt der gemeinsame Pool der JVM, [ForkJoinPool.commonPool()] , die Funktion aus; wie man den Executor wählt, sehen wir später. Für eine Verarbeitung ohne Ergebnis ([Runnable]) verwenden wir [runAsync], das ein [CompletableFuture<Void>] zurückgibt;
- Zeile 12: Die Methode [state()] (Java 19) gibt den Status der Operation zurück: [RUNNING] (läuft), [SUCCESS] (erfolgreich beendet), [FAILED] (wegen einer Ausnahme beendet) oder [CANCELLED] (abgebrochen). Dies sind die Konstanten der Enumeration [Future.State]; die letzten drei sind Endzustände: Eine beendete Operation ändert ihren Zustand nicht mehr;
- Zeile 14: [join()] wartet auf das Ende der Operation und gibt ihr Ergebnis zurück. Wie [Thread.join] im vorherigen Kapitel ist dies ein blockierendes Warten: Der aktuelle Thread wird angehalten (hier der Haupt-Thread, was bei einem kleinen Konsolenprogramm kein Problem ist);
- Zeilen 17–22: Ein [CompletableFuture] , das von seinem Ersteller als „laufend“ erzeugt und nach 300 ms von einem Timer beendet wird ([completeOnTimeout], Java 9). In dieser Zeit ist kein Thread belegt: Dies ist das asynchrone Gegenstück zu [Thread.sleep(300)]. Sein Typ ist [CompletableFuture<Void>]: Er liefert kein Ergebnis ([Void] ist die zu [void] gehörende Klasse; ihr einziger Wert ist [null]);
- Zeilen 25–28: [completedFuture(42)] gibt ein bereits beendetes [CompletableFuture] mit dem Ergebnis 42 zurück, und [failedFuture(exception)] (Java 9) gibt ein [CompletableFuture] zurück, das bereits fehlgeschlagen ist. Sie werden verwendet, wenn eine Methode ein
*[CompletableFuture]zurückgeben muss, das Ergebnis aber bereits hat (zum Beispiel einen zwischengespeicherten Wert) oder bereits weiß, dass sie fehlschlagen wird. [resultNow()] und [exceptionNow()] (Java 19) geben das Ergebnis oder die Ausnahme einer beendeten Operation zurück, ohne zu warten (sie lösen eine [IllegalStateException]* aus, wenn die Operation nicht im gewünschten Zustand ist); - Zeilen 31–37: Eine Operation, deren Funktion eine Ausnahme auslöst, endet im Zustand [FAILED]. Die Ausnahme wird im [CompletableFuture] gespeichert, und [join()] löst eine [CompletionException] (eine ungeprüfte Ausnahme) aus, deren Ursache ([getCause()]) die ursprüngliche Ausnahme ist, in diesem Fall eine [NumberFormatException];
- Zeilen 40–45: [get()], die von der Schnittstelle [Future] geerbte Methode, wartet ebenfalls blockierend, kapselt die Ausnahme aber in eine [ExecutionException] – eine geprüfte Ausnahme – und kann außerdem eine [InterruptedException] auslösen, die ebenfalls geprüft ist: Der Aufruf steht daher in einem
*[try / catch], der die erste abfängt, und die Methode*[main]deklariert die zweite (Zeile 2). [join()] ist in Code, der [CompletableFuture] manipuliert, bequemer; [get()] ist die einzige verfügbare Methode für ein einfaches [Future], und es gibt eine Version mit Zeitlimit, [get(timeout, unit)]; - Zeilen 48–50: eine Fortsetzung. [f2.thenApply(function)] gibt ein neues [CompletableFuture] zurück, das mit dem Ergebnis der Funktion, angewandt auf das Ergebnis von [f2] , abgeschlossen wird, sobald [f2] beendet ist. Hier ignoriert die Funktion ihren Parameter ([null]) und gibt 42 zurück: Das ergibt ein [CompletableFuture<Integer>]. [thenAccept] hängt eine Funktion an, die das Ergebnis verbraucht, ohne eines zu erzeugen ([Consumer<T>]), und gibt ein [CompletableFuture<Void>] zurück. Schlägt die ursprüngliche Operation fehl, wird die Fortsetzung nicht ausgeführt, und der Fehler pflanzt sich entlang der Kette fort;
- Zeilen 53–55: die booleschen Methoden [isDone()] (beendet, gleich auf welche Weise), [isCompletedExceptionally()] (mit einer Ausnahme beendet oder abgebrochen) und [isCancelled()] (abgebrochen).
In [CompletableFuture] gibt es zahlreiche Methoden (mehr als fünfzig). Die folgende Tabelle listet diejenigen auf, die wir verwenden werden:
Methode | Rolle |
[supplyAsync(f)], [runAsync(r)] | Eine Funktion (mit oder ohne Ergebnis) mithilfe eines Executors ausführen |
[completedFuture(v)], [failedFuture(e)] | Eine bereits beendete Operation erzeugen, erfolgreich oder nicht |
[complete(v)], [completeExceptionally(e)] | eine Aufgabe selbst beenden |
[thenApply(f)] | Das Ergebnis transformieren: [T → U] |
[thenAccept(c)], [thenRun(r)] | Das Ergebnis verwenden oder nach der Operation eine Aktion ausführen |
[thenCompose(f)] | Eine weitere asynchrone Operation anhängen: [T → CompletableFuture<U>] |
[thenCombine(other, f)] | Die Ergebnisse zweier parallel ausgeführter Operationen kombinieren |
[allOf(...)], [anyOf(...)] | Auf das Ende aller Operationen oder der ersten warten |
[exceptionally(f)], [handle(f)], [whenComplete(c)] | Einen Fehler behandeln oder beobachten |
[orTimeout(...)], [completeOnTimeout(...)] | die Dauer einer Operation begrenzen |
[join()], [get()] | Auf das Ergebnis warten und dabei den aktuellen Thread blockieren |
Die Methoden [thenXxx], [handle] und [whenComplete] gibt es auch in der Version [thenXxxAsync]: Den Unterschied besprechen wir im Abschnitt „Welcher Thread führt den Rest des Codes aus?“
9.3. Asynchrone Methoden
9.3.1. Erster Ansatz: ein CompletableFuture zurückgeben
In Java ist eine asynchrone Methode einfach eine Methode, die eine Operation startet und sofort, ohne zu warten, ein [CompletableFuture] zurückgibt, das sie darstellt:
- [CompletableFuture<Void>] , wenn die Operation kein Ergebnis liefert;
- [CompletableFuture<T>] , wenn sie ein Ergebnis vom Typ [T] liefert.
Die Sprache schreibt keine Namenskonventionen vor. Java-Bibliotheken hängen an diese Methoden oft das Suffix [Async] an ([sendAsync], [supplyAsync]), aber das ist keine Regel: Der Rückgabetyp genügt, um sie zu erkennen.
Das Programm [Async04.java] kocht Kaffee und zählt Zuckerstücke:
Ergebnisse:
Erläuterungen:
- Zeilen 40–43: Die Methode [delay] ist das asynchrone Gegenstück zu [Thread.sleep]: Sie gibt ein [CompletableFuture<Void>] zurück, das nach Ablauf der Zeitspanne abgeschlossen wird, ohne einen Thread zu belegen. Wir verwenden sie in vielen Beispielen, um E/A zu simulieren;
- Zeilen 17–24: eine Operation ohne Ergebnis. Die Methode zeigt eine erste Meldung an, beschreibt dann die Abfolge der Schritte und gibt sofort das letzte [CompletableFuture] zurück: Deshalb erscheint Zeile 4 der Ergebnisse unmittelbar nach Zeile 3 und nicht anderthalb Sekunden später. Die Schritte werden später ausgeführt, jeder erst nach Abschluss des vorherigen:
- Zeile 21: [thenRun(action)] führt eine Aktion aus, wenn die vorherige Operation abgeschlossen ist;
- Zeile 22: [thenCompose(function)] löst eine weitere asynchrone Operation aus: Die Funktion gibt selbst ein [CompletableFuture] zurück (hier eine neue Verzögerung von 500 ms), und das von [CompletableFuture] zurückgegebene [thenCompose] wird erst abgeschlossen, wenn diese zweite Operation beendet ist. Mit [thenApply] hätten wir ein [CompletableFuture<CompletableFuture<Void>>] erhalten, das bereits abgeschlossen gewesen wäre, sobald die zweite Verzögerung begann: [thenCompose] verhält sich zu [thenApply] wie [flatMap] zu [map] in der Stream-API;
- Zeilen 27–38: Eine Operation, die eine ganze Zahl zurückgibt. Eine Schleife kann nicht bei jeder Iteration „warten“: Sie baut die Abfolge der Schritte auf, wobei jede Iteration der bestehenden Abfolge eine Verzögerung und eine Anzeige hinzufügt, ausgehend von einem bereits berechneten [CompletableFuture] (Zeile 29). Die gesamte Kette wird in wenigen Mikrosekunden aufgebaut und läuft dann im Takt der Verzögerungen ab. Die Variable [number] (Zeile 32) ist nötig, weil ein Lambda nur eine lokale Variable verwenden kann, die effektiv final ist, was [i] nicht ist. Schließlich wandelt [thenApply] die Kette in ein [CompletableFuture<Integer>] um, dessen Ergebnis die Anzahl der Zuckerstücke ist;
- Zeilen 6–10: Das Hauptprogramm ruft beide Methoden auf. Es erhält zwei [CompletableFuture] -Werte und fährt mit der Ausführung fort. Die beiden Operationen laufen dann „gleichzeitig“ ab: Die Zuckerstücke werden gezählt (Zeilen 7–9 der Ergebnisse), während die Maschine aufheizt;
- Zeile 12: [preparation.thenCombine(counting, function)] gibt ein beendetes [CompletableFuture] zurück, wenn beide Operationen beendet sind, zusammen mit dem Ergebnis der auf ihre beiden Ergebnisse angewandten Funktion: Hier wird die Anzahl der Zuckerstücke übernommen. [join()] wartet auf dieses Ergebnis. Der Kaffee ist nach 1,5 Sekunden fertig – der Dauer der längeren der beiden Operationen – und nicht nach 2,1 Sekunden (1,5 + 3 × 0,2).
Wir sehen die Stärken und Grenzen dieses Ansatzes. Kein Thread wartet: Die Schritte werden vom Timer-Thread im Takt der Zeitintervalle ausgeführt. Aber der Code liest sich nicht mehr wie eine Folge von Anweisungen: Die Schleife in [countSugars] tut nicht, was eine Schleife üblicherweise tut (sie baut eine Kette auf, statt Iterationen auszuführen), und ein einfaches [if] oder [try / catch] mitten in den Schritten erfordert eigene Methoden. Das ist der Preis, den man zahlt, wenn die Sprache keine Schlüsselwörter wie [await] bietet.
9.3.2. Zweiter Ansatz: blockierender Code auf virtuellen Threads
Virtuelle Threads erlauben es, dieselben Methoden als gewöhnliche, blockierende Methoden zu schreiben. Das Programm [Async05.java] kocht dieselbe Tasse Kaffee:
Ergebnisse:
Erläuterungen:
- Zeilen 20–37: Beide Operationen sind gewöhnliche Methoden: [makeCoffee] gibt nichts zurück ([void]), und [countSugars] gibt einen [int] zurück. Die Aufrufe sind blockierende [Thread.sleep]-Operationen; die Schleife ist eine echte Schleife. Nichts in diesen Methoden deutet darauf hin, dass sie nebenläufig ausgeführt werden: Sie könnten direkt aufgerufen werden;
- Zeilen 39–48: Die Methode [sleep] ruft [Thread.sleep] auf und wandelt jede [InterruptedException] (geprüfte Ausnahme) in eine [CancellationException] (ungeprüfte Ausnahme) um, nachdem das Unterbrechungs-Flag des Threads zurückgesetzt wurde: Das ist die Regel, wenn man eine [InterruptedException] abfängt, ohne sie weiterzugeben (wir kommen im Abschnitt über den Abbruch darauf zurück);
- Zeile 6: ein Executor, der für jede Aufgabe einen virtuellen Thread erzeugt. Er wird in einem [try] mit Ressource deklariert: Seine Methode [close()] wartet, bis alle Aufgaben beendet sind;
- Zeilen 8 und 11: [submit] delegiert jede Methode an einen neuen virtuellen Thread und gibt ein [Future] zurück. Die Methodenreferenz [this::makeCoffee] ist ein [Runnable] (die Methode gibt nichts zurück), was ein [Future<?>] ergibt; das Lambda [() -> countSugars(3)] ist ein [Callable<Integer>], was ein [Future<Integer>] ergibt;
- Zeilen 14–15: Das Hauptprogramm wartet mit [get()] auf beide Ergebnisse. Das ist ein blockierendes Warten des Haupt-Threads, das hier folgenlos bleibt;
- die Ergebnisse sind dieselben wie bei [Async04.java]: insgesamt 1,5 Sekunden, wobei die Zuckerstücke gezählt werden, während die Maschine aufheizt. Während des Wartens ist kein Systemthread blockiert: Die beiden virtuellen Threads sind von ihren Trägerthreads gelöst.
Mit virtuellen Threads ist Asynchronität keine Frage des Schreibens von Code mehr, sondern der Ausführung: Wir schreiben blockierenden Code, und die Wahl des Executors (virtuelle Threads statt eines Pools von Plattform-Threads) entscheidet, ob das Warten Systemthreads blockiert. Deshalb profitieren bestehende Java-Bibliotheken (JDBC, Dateien, Sockets, [HttpClient.send] …), die alle blockierend geschrieben sind, ohne Änderung von virtuellen Threads.
9.3.3. Was die JVM tut
Wie kann ein virtueller Thread mitten in einer Schleife unterbrochen werden, seinen Trägerthread freigeben und später an derselben Stelle mit denselben Werten der lokalen Variablen fortgesetzt werden, möglicherweise auf einem anderen Trägerthread? Ein virtueller Thread ist ein Java-Objekt ([java.lang.VirtualThread], eine von [Thread] abgeleitete Klasse), das einen eigenen Aufrufstack hat. Zur Ausführung „montiert“ die JVM ihn auf einen Trägerthread – einen Plattform-Thread eines hierfür reservierten [ForkJoinPool] , der standardmäßig so viele Threads hat, wie Prozessoren vorhanden sind. Ruft der virtuelle Thread eine blockierende Operation auf ([Thread.sleep], Lesen von einem Socket; [BlockingQueue.take], Warten auf eine Sperre …), blockieren die Klassen der JVM – hierfür in Java 21 neu geschrieben – den tragenden Thread nicht:
- sie registrieren die Operation beim System (ein Timer für eine Verzögerung, der E/A-Benachrichtigungsmechanismus des Systems – [epoll] unter Linux – für einen Socket);
- sie „demontieren“ den virtuellen Thread: Die Frames seines Aufrufstacks werden als Objekt namens Continuation auf den Heap kopiert, und der Trägerthread wird an den [ForkJoinPool] zurückgegeben, der ihm einen anderen ausführungsbereiten virtuellen Thread zuweist;
- Wenn die Operation abgeschlossen ist, wird der virtuelle Thread wieder ausführungsbereit: Er wird auf den ersten verfügbaren Trägerthread neu montiert, seine Stack-Frames werden wieder kopiert, und die Ausführung wird unmittelbar nach dem blockierenden Aufruf fortgesetzt.
Das ist das Prinzip hinter Callback-Methoden („ruf mich zurück, wenn die Operation abgeschlossen ist“), aber es ist die JVM, die die Ausführung zerlegt, die Variablen sichert und den Kontext auf der Ebene des Aufrufstacks wiederherstellt, ohne dass der Quellcode eine Spur davon zeigt. Andere Sprachen übertragen diese Aufgabe dem Compiler, der jede [async]-Methode in eine „Zustandsmaschine“ umwandelt; Java überträgt sie der JVM, die dadurch den gesamten bestehenden Code auf dieselbe Weise behandeln kann.
Es sind zwei Einschränkungen zu beachten:
- Bestimmte Operationen können den virtuellen Thread nicht ablösen; er bleibt daher an seinen Host-Thread „gepinnt“, der während des Wartens blockiert ist. Dies geschieht während der Ausführung einer nativen Methode und bei den meisten Lese- und Schreibzugriffen auf Dateien (das System bietet für Dateien keine Benachrichtigung, die von der JVM genutzt werden kann); in diesem Fall [ForkJoinPool] kompensiert dies, indem er vorübergehend einen zusätzlichen Carrier-Thread erzeugt. Bis Java 23 galt dies auch für einen virtuellen Thread, der innerhalb eines [synchronized]-Blocks wartet; seit Java 24 ist das nicht mehr der Fall;
- Ein virtueller Thread beschleunigt keine Berechnung: Ein virtueller Thread, der eine Berechnung durchführt, belegt seinen Host-Thread für die gesamte Dauer der Berechnung. Virtuelle Threads sind für Programme gedacht, die viel warten, nicht für solche, die viel rechnen (für Letztere stehen Thread-Pools und parallele Streams aus dem vorigen Kapitel zur Verfügung).
9.3.4. Welcher Thread führt den nächsten Abschnitt aus?
Das Programm [Async06.java] zeigt den Thread an, der jeden Codeabschnitt ausführt:
Ergebnisse:
Kommentare:
- Zeile 3: Der gemeinsame Pool ([ForkJoinPool.commonPool()]), der Standard-Executor für [CompletableFuture], hat einen Parallelitätsgrad, der der Anzahl der Prozessoren minus eins entspricht, also 1 auf unserem Rechner mit 2 Prozessoren (Zeile 2 der Ergebnisse);
- Zeile 6: Die Fortsetzung eines [CompletableFuture], der bereits abgeschlossen ist, wird sofort von dem Thread ausgeführt, der sie angehängt hat: dem Thread [main] (Zeile 3);
- Zeilen 9–12: Ist die Operation nicht abgeschlossen, wird die Fortsetzung von dem Thread ausgeführt, der sie abschließt: dem Timer-Thread für die Zeitüberschreitung bei [delay(100)] (Zeile 4), dem Thread [deliverer], der [complete] für die Bestellung aufruft (Zeile 5). Der Thread, der eine nicht asynchrone Fortsetzung ausführt, lässt sich also nicht wählen; bei einer kurzen Aktion spielt das keine Rolle, eine lange oder blockierende Fortsetzung würde diesen Thread jedoch lahmlegen (zum Beispiel den Timer-Thread, der alle Zeitüberschreitungen von [CompletableFuture] verwaltet);
- Zeilen 15–23: Die [xxxAsync]-Varianten ([thenRunAsync], [thenApplyAsync] …) delegieren die Fortsetzung an einen Executor: ohne zusätzliche Parameter an den gemeinsamen Pool (Zeile 6 der Ergebnisse); mit einem Executor als letztem Parameter an diesen Executor. So lassen sich Plattform-Threads wählen (Zeilen 7–8: ein Pool aus zwei Threads, deren Namen von einer Thread-Factory festgelegt werden, [ThreadFactory], erzeugt mit [Thread.ofPlatform().name("pool-", 1).factory()]) oder virtuelle Threads (Zeile 9). [supplyAsync] und [runAsync] akzeptieren ebenfalls einen Executor;
- Zeilen 26–38: Zwei virtuelle Threads, die eine Nachricht ausgeben und dann schlafen, dreimal hintereinander. Die Ergebnisse zeigen, dass sie nicht an einen einzelnen Host-Thread gebunden bleiben: Der virtuelle Thread Nr. 31 (A) beginnt bei [worker-1] und endet bei [worker-2], während Nr. 32 (B) das Gegenteil tut. Solange einer schläft, steht sein Carrier-Thread dem anderen zur Verfügung. In einem virtuellen Thread darf man daher nie davon ausgehen, dass der Code nach einer Wartezeit vom selben Carrier-Thread ausgeführt wird wie der Code davor; es ist aber immer derselbe virtuelle Thread, und darauf kommt es für das Programm an ([Thread.currentThread()] liefert den virtuellen Thread; seine Variablen, [ThreadLocal], bleiben erhalten).
Diese Art, mehrere Operationen gleichzeitig auszuführen, ohne die Anzahl der Systemthreads zu erhöhen, nennt man Nebenläufigkeit (Concurrency). Sie unterscheidet sich von der Parallelität, bei der mehrere Berechnungen gleichzeitig auf mehreren Prozessoren ausgeführt werden (wie im vorigen Kapitel besprochen: Thread-Pools, parallele Streams). Asynchronität erleichtert die E/A-Nebenläufigkeit; sie macht Berechnungen nicht schneller.
Die Wahl des Executors ist daher wichtig:
- Der gemeinsame Pool eignet sich für kurze Fortsetzungen und kurze Berechnungen; blockierende Operationen sollten dort nicht ausgeführt werden, da sonst die in [Async01.java] beschriebene Starvation droht (er hat auf unserem Rechner nur einen Thread);
- Für eine blockierende Operation (E/A, JDBC-Aufrufe oder [Thread.sleep]) verwenden Sie einen Executor für virtuelle Threads: [CompletableFuture.supplyAsync(supplier, virtualExecutor)];
- Für eine grafische Benutzeroberfläche übergibt man einen Executor, der die Fortsetzung vom UI-Thread ausführen lässt, wodurch die grafischen Komponenten aktualisiert werden können: mit Swing [thenAcceptAsync(action, SwingUtilities::invokeLater)] (die Methodenreferenz [SwingUtilities::invokeLater] ist ein gültiger [Executor], da [Executor] ein funktionales Interface ist, dessen einzige Methode einen [Runnable] entgegennimmt); mit JavaFX [Platform::runLater].
9.3.5. Das Hauptprogramm
In anderen Sprachen muss die Hauptmethode eines asynchronen Programms auf besondere Weise deklariert werden. In Java gibt es diese Anforderung nicht: Die Methode [main] wird vom Plattform-Thread [main]ausgeführt, und diese Methode muss selbst darauf warten, dass die von ihr gestarteten Operationen abgeschlossen werden – mit [join()] oder [get()]. Dies ist der einzige Ort, an dem ein blockierendes Warten auf einen [CompletableFuture] normal ist. Das Programm [Async07.java] führt einen asynchronen Countdown durch:
Ergebnisse, zuerst mit und dann ohne Argument:
Kommentare:
- Zeile 2: Der Parameter [args] von [main] erhält die Befehlszeilenargumente, die nach dem Dateinamen stehen: [java Async07.java 3];
- Zeilen 4–8: Fehlt das Argument oder ist es keine positive ganze Zahl (regulärer Ausdruck [\d+]: eine oder mehrere Ziffern), beendet sich das Programm mit [System.exit(1)]. Die an [System.exit] übergebene ganze Zahl ist der Exit-Code des Programms (0 für Erfolg, jeder andere Wert für einen Fehler), der von einem Skript geprüft werden kann: [echo $?] unter Linux (zweites Ergebnis), [echo %ERRORLEVEL%] unter Windows. Ein Programm, dessen Methode [main] normal endet, liefert den Code 0;
- Zeilen 16–23: ein asynchroner Countdown. Eine asynchrone Schleife wird natürlicherweise mithilfe von Rekursion umgesetzt: Jeder Schritt gibt eine Nachricht aus und führt dann mit [thenCompose] eine Verzögerung von einer Sekunde ein, gefolgt vom nächsten Schritt. Es gibt keinen Aufrufstapel: Der rekursive Aufruf erfolgt über die Fortsetzung, eine Sekunde später;
- Zeilen 9–12: Die Methode [countDown] gibt ihre erste Nachricht aus und gibt dann die Kontrolle zurück (Zeilen 2–3 der Ergebnisse); das Hauptprogramm wartet mit [join()] auf das Ende der Operation. Ohne dieses Warten würde [main] sofort enden und mit ihm das Programm: Die JVM wird beendet, wenn nur noch Daemon-Threads übrig sind, und die Threads des Timers und des gemeinsamen Pools sind Daemons. Dasselbe gilt für virtuelle Threads, die immer Daemons sind: Ein Programm muss das Ende der von ihm gestarteten virtuellen Threads abwarten (mit [join], [get], oder der Methode [close] ihres Executors).
9.4. Sequenzielle und nebenläufige Ausführung
9.4.1. allOf und invokeAll
Das Kaffeebeispiel hat es gezeigt: Der Zeitpunkt, zu dem eine asynchrone Operation gestartet wird, und der Zeitpunkt, zu dem auf sie gewartet wird, können auseinanderfallen. Die Schreibweise [method().join()] startet die Operation und wartet sofort auf sie; die Schreibweise [var f = method();] und später [f.join();] erlaubt es, dazwischen andere Operationen zu starten. Das Programm [Async08.java] vergleicht die beiden Ansätze anhand von Operationen, die eine Sekunde dauern:
Ergebnisse:
Kommentare:
- Zeilen 41–45: die simulierte Operation: eine Verzögerung von einer Sekunde, gefolgt von einer „Temperatur“, die aus der Länge des Städtenamens abgeleitet wird;
- Zeilen 6–8: Jede Operation wird gestartet und dann abgewartet, bevor die nächste beginnt. Die drei Operationen werden nacheinander ausgeführt: 3 Sekunden (Zeile 2 der Ergebnisse). Das ist der richtige Ansatz, wenn eine Operation das Ergebnis der vorherigen benötigt (dann würde man stattdessen eine Kette aus [thenCompose] schreiben);
- Zeilen 13–15: Die drei Operationen werden gestartet, ohne aufeinander zu warten. Sie laufen gleichzeitig;
- Zeile 16: [CompletableFuture.allOf(...)] liefert einen [CompletableFuture<Void>], der abgeschlossen ist, sobald alle übergebenen Operationen beendet sind. Wir warten darauf mit [join()]: 1 Sekunde statt 3 (Zeile 3);
- Zeilen 17–18: Die drei Operationen sind abgeschlossen, daher liefert [resultNow()] ihre Ergebnisse sofort;
- Zeilen 22–27: der Fall einer Liste von Operationen. [allOf] erwartet ein Array ([CompletableFuture<?>...]): Die Methode [toArray(CompletableFuture[]::new)] der Liste erzeugt es. [allOf] liefert die Ergebnisse nicht: Sie werden in einer Fortsetzung gesammelt, indem [join()] auf jeder Operation aufgerufen wird, was nicht blockiert, da alle abgeschlossen sind. Die Ergebnisliste erhält man in der Reihenfolge der Operationen (nicht in der Reihenfolge, in der sie abgeschlossen wurden). Der Ausdruck [cities.stream().map(this::readTemperature).toList()] ruft die Methode für jede Stadt auf und startet dadurch sechs Operationen gleichzeitig; alle sechs zusammen benötigen eine Sekunde (Zeile 4);
- Zeilen 29–38: dasselbe mit einer blockierenden Methode (Zeilen 47–51), die von virtuellen Threads ausgeführt wird. Die Methode [invokeAll] eines Executors erhält eine Sammlung von [Callable<T>], startet sie alle und liefert die Liste ihrer [Future<T>] zurück, wenn alle abgeschlossen sind: Dies ist das blockierende Äquivalent von
*[allOf]. Der Typ-Cast [(Callable<Integer>)] in Zeile 33 teilt dem Compiler den Typ des Lambdas mit, den er in einem [map]*nicht selbst ableiten kann. Die sechs Operationen benötigen zusammen eine Sekunde (Zeile 5).
9.4.2. anyOf
[CompletableFuture.anyOf(...)] liefert einen [CompletableFuture<Object>] , der abgeschlossen wird, sobald eine der übergebenen Operationen beendet ist, mit dem Ergebnis (oder der Ausnahme) dieser Operation. Das Programm [Async09.java] nutzt ihn auf zwei Arten:
Ergebnisse:
Kommentare:
- Zeilen 6–9: Es werden drei Spiegelserver abgefragt; sie enthalten alle dieselben Informationen und antworten unterschiedlich schnell. Die drei Operationen werden in einer Liste gespeichert;
- Zeile 11: [anyOf] liefert einen [CompletableFuture<Object>], dessen Ergebnis das der ersten abgeschlossenen Operation ist. Sein Typ ist [Object] , weil die an [anyOf] übergebenen Operationen unterschiedliche Ergebnistypen haben können: Um ihn als Zeichenkette zu verwenden, müsste man ihn casten. Die erste Antwort trifft nach 300 ms ein (Zeile 2 der Ergebnisse);
- Zeile 14: Die anderen Anfragen werden von [anyOf] nicht beendet; sie laufen bis zu ihrem Ende weiter. Hier warten wir, bis sie alle Antworten angezeigt haben (Zeile 3);
- Zeilen 19–26: eine häufige Verwendung von [anyOf]: die Dauer eines Wartens zu begrenzen, indem man ein „Rennen“ zwischen der Operation und einer Zeitüberschreitung veranstaltet. Ist die Operation am Ende des Rennens noch nicht abgeschlossen, hat die Zeitüberschreitung gewonnen: Die Operation hat zu lange gedauert (Zeile 4). [CompletableFuture] bietet für diesen Fall mit der Methode [orTimeout] eine direktere Schreibweise, die später vorgestellt wird.
9.4.3. Ergebnisse verarbeiten, sobald sie eintreffen
Oft möchte man die Ergebnisse mehrerer Operationen verarbeiten, sobald sie vorliegen, ohne auf die langsamste zu warten. Mit [CompletableFuture] ist das einfach: Man hängt an jede Operation eine Fortsetzung an. Für Aufgaben, die an einen Executor übergeben werden, liefert die Klasse [ExecutorCompletionService] (Java 5) die [Future]-Objekte in der Reihenfolge, in der die Aufgaben abgeschlossen werden. Das Programm [Async10.java] verarbeitet fünf „Dateien“, deren Verarbeitung jeweils zwischen 100 und 900 ms dauert, auf beide Arten:
Ergebnisse:
Kommentare:
- Zeilen 7–11: Jede Verarbeitungsaufgabe erhält ihre eigene Fortsetzung, [thenAccept(this::display)], die ausgeführt wird, sobald sie beendet ist: Datei 3 (100 ms) wird als Erste angezeigt, Datei 0 (900 ms) als Letzte (Zeilen 2–6 der Ergebnisse). Die Methode [process] (Zeilen 31–35) liefert nach der angegebenen Dauer einen abgeschlossenen [CompletableFuture<String>] mit der gewünschten Nachricht ([completeOnTimeout] erhält direkt den Ergebniswert). Anhand der Liste der Fortsetzungen wird mit [allOf] abgewartet, bis alle Anzeigen beendet sind;
- Zeilen 16–27: Ein [CompletionService<T>] umhüllt einen Executor (hier einen Executor für virtuelle Threads). Seine Methode [submit] startet eine Aufgabe; seine Methode [take()] wartet blockierend auf die nächste abgeschlossene Aufgabe und liefert deren [Future], dessen Ergebnis sofort von [get()]zurückgegeben wird. Die Schleife in den Zeilen 24–26 verarbeitet die Dateien daher in der Reihenfolge ihres Abschlusses (Zeilen 8–12);
- In beiden Fällen dauert der gesamte Vorgang 900 ms – die Dauer der längsten Verarbeitung – und jedes Ergebnis wird so früh wie möglich angezeigt.
9.5. Ausnahmen in asynchronem Code
9.5.1. Weitergabe, exceptionally, handle, whenComplete
Eine Ausnahme, die von einer asynchronen Operation ausgelöst wird, wird nicht an den Code zurückgeworfen, der die Operation gestartet hat: Sie wird im [CompletableFuture] gespeichert, der in den Zustand [FAILED] übergeht. Sie wird dann entlang der Kette von Fortsetzungen weitergegeben, bis sie eine Methode erreicht, die sie behandelt, oder bis sie [join()] erreicht, das sie in eine [CompletionException] verpackt erneut auslöst. Das Programm [Async11.java] untersucht die verschiedenen Fälle:
Ergebnisse:
Kommentare:
- Zeilen 54–64: die getestete Methode. Sie prüft zuerst ihren Parameter und löst eine [IllegalArgumentException] aus, wenn die Zeichenkette [null] oder leer ist. Andernfalls liefert sie eine Operation, die 100 ms wartet und dann die gesamte Zeichenkette konvertiert, was eine [NumberFormatException] auslöst, wenn die Zeichenkette keine Zahl ist;
- Zeilen 4–10: der Standardfall. Die Ausnahme, die von [Integer.parseInt] in der Fortsetzung von Zeile 63 ausgelöst wird, wird vom [CompletableFuture] abgefangen; [join()] löst die Ausnahme in eine [CompletionException] verpackt erneut aus, aus der [getCause()] die ursprüngliche Ausnahme liefert (Zeile 2 der Ergebnisse);
- Zeile 13: [exceptionally(function)] liefert einen [CompletableFuture] , der dasselbe Ergebnis wie die Operation hat, wenn sie erfolgreich ist, und andernfalls das Ergebnis der auf die Ausnahme angewendeten Funktion: Das ist das [catch] der Welt von [CompletableFuture]. Hier wird ein Fehlschlag durch den Wert -1 ersetzt (Zeile 3);
- Zeilen 17–23: zwei weitere Methoden, angewendet auf eine erfolgreiche und anschließend auf eine fehlgeschlagene Operation:
- [whenComplete(action)] erhält das Ergebnis und die Ausnahme (eines von beiden ist [null]) und ändert nichts: Der [CompletableFuture], den sie liefert, hat dasselbe Ergebnis oder dieselbe Ausnahme wie die Operation. Sie dient der Beobachtung (Protokollierung, Freigabe einer Ressource): Das ist das [finally] der Welt von [CompletableFuture];
- [handle(function)] erhält ebenfalls das Ergebnis und die Ausnahme und liefert in beiden Fällen einen neuen Wert: Sie wandelt sowohl einen Erfolg als auch einen Fehlschlag in ein Ergebnis um;
- Die Zeilen 6 und 7 der Ergebnisse zeigen eine Falle: Die Ausnahme, die die Fortsetzungen erhalten, ist nicht die [NumberFormatException] , sondern eine [CompletionException] , die sie umhüllt, weil der Fehler in einem vorherigen Schritt der Kette aufgetreten ist (der Fortsetzung in Zeile 63). Die Methode [cause] (Zeilen 66–69) führt zur ursprünglichen Ausnahme zurück: Wir gewöhnen uns an, sie so zu schreiben;
- Zeilen 26–31: ein wichtiger Unterschied zu den [async]-Methoden anderer Sprachen: Eine Methode, die einen [CompletableFuture] liefert, ist eine gewöhnliche Methode, die unmittelbar beim Aufruf eine Ausnahme auslösen kann, noch bevor ein [CompletableFuture] erzeugt wird. Das ist hier bei einer leeren Zeichenkette der Fall (Zeile 8 der Ergebnisse). Der aufrufende Code muss daher mit beiden Fehlerarten rechnen, oder die Methode muss eine bereits fehlgeschlagene Operation liefern ([return CompletableFuture.failedFuture(new IllegalArgumentException(...));]), was oft vorzuziehen ist;
- Zeilen 34–38: Wir warten mit [allOf] auf vier Operationen, von denen zwei fehlschlagen. Der [CompletableFuture] von [allOf] schlägt seinerseits fehl, aber mit nur einer der Ausnahmen (Zeile 9 der Ergebnisse);
- Zeilen 43–50: Jede Operation hat ihr Ergebnis oder ihre Ausnahme behalten. Wir untersuchen ihren Status mit einem [switch]; [exceptionNow()] liefert die ursprüngliche Ausnahme ohne Hülle. Der Fehlschlag von [allOf] hindert die anderen Operationen nicht daran, erfolgreich zu sein (Zeilen 10 und 12).
Bei virtuellen Threads stellt sich das Problem nicht in derselben Weise: Der von einem virtuellen Thread ausgeführte Code ist gewöhnlicher Code, in dem sich Ausnahmen wie üblich fortpflanzen und von [try / catch] abgefangen werden. Nur die Grenze zwischen zwei Threads erfordert besondere Aufmerksamkeit: Eine Ausnahme einer an einen Executor übergebenen Aufgabe wird in ihrem [Future] gespeichert, und [get()] löst sie in eine [ExecutionException] verpackt erneut aus.
9.5.2. Vergessene Operationen
Was geschieht mit der Ausnahme einer Operation, auf die niemand wartet? Das Programm [Async12.java] zeigt es:
Ergebnisse:
Kommentare:
- Zeilen 4–5: [Thread.setDefaultUncaughtExceptionHandler] richtet den Handler ein, der aufgerufen wird, wenn eine Ausnahme von keinem Code in einem Thread abgefangen wird, kurz vor dem Ende dieses Threads. Ohne ihn zeigt die JVM den Stacktrace der Ausnahme in der Fehlerausgabe an;
- Zeilen 8–12: Auf die Operation wird gewartet, und ihre Ausnahme wird normal abgefangen;
- Zeilen 14–16: Die Operation wird gestartet und dann vergessen. Ihre Ausnahme wird im [CompletableFuture] gespeichert, den niemand je abfragen wird: Sie ist verloren, ohne auch nur eine Meldung;
- Zeilen 18–21: Dasselbe gilt für eine Aufgabe, die mit [submit] an einen Executor übergeben wurde: Ihre Ausnahme wird im zurückgegebenen [Future] gespeichert, der ignoriert wird;
- Zeile 24: Ein direkt gestarteter Thread hat keinen [Future]: Die Ausnahme, die er nicht behandelt, beendet den Thread und erreicht den Handler für nicht abgefangene Ausnahmen (Zeile 8 der Ergebnisse). Das Programm läuft jedoch weiter;
- Zeilen 28–31: die richtige Art, eine Operation zu starten, ohne auf sie zu warten: Man hängt an sie eine Fortsetzung [exceptionally] (oder [whenComplete]) an, die den Fehlschlag behandelt, hier durch die Ausgabe einer Meldung (Zeile 7);
- Die Zeilen 33–39 zeigen, dass das Programm in allen Fällen bis zu seinem normalen Ende weiterläuft. Das unterscheidet sich von manchen Sprachen, in denen eine nicht abgefangene Ausnahme das Programm beenden kann; in Java bleibt sie unbemerkt, was nicht besser ist: Ein Fehler, den niemand sieht, bedeutet verlorene Daten.
Die Regel lautet daher: Eine gestartete Operation muss abgewartet werden ([join], [get], [allOf] oder die Methode [close] eines Executors, die auf seine Aufgaben wartet), oder sie muss eine Fortsetzung erhalten, die ihren Fehlschlag behandelt. Werkzeuge zur Codeanalyse (SpotBugs, die Inspektionen von IntelliJ IDEA) können außerdem das ignorierte Ergebnis einer Methode beanstanden, die einen [Future] liefert.
9.6. Abbruch und Fristen
9.6.1. Future.cancel und Beenden von Threads
Eine lang laufende Operation muss abgebrochen werden können: Der Benutzer hat auf [Cancel] geklickt, ein Client hat die Verbindung zum Server getrennt, die Anwendung wurde beendet oder eine Zeitüberschreitung ist eingetreten. Java verwendet dafür einen kooperativen Mechanismus – die Unterbrechung von Threads:
- Die Methode [interrupt()] eines Threads setzt dessen Unterbrechungsflag; sie beendet den Thread nicht (die Methode [Thread.stop], die einen Stopp erzwang, ist seit Java 20 veraltet: Sie löst eine [UnsupportedOperationException] aus);
- Wenn der Thread in einem unterbrechbaren Warten blockiert ist ([Thread.sleep], [Object.wait], [Thread.join], [BlockingQueue.take], [Future.get] …), wird das Warten sofort unterbrochen und löst eine [InterruptedException] aus, wobei das Flag zurückgesetzt wird;
- Ein Thread, der Berechnungen durchführt, prüft regelmäßig sein eigenes Flag mit [Thread.currentThread().isInterrupted()] und beendet sich ordnungsgemäß, wenn es gesetzt ist;
- Die Methode [cancel(true)] eines von einem Executor gelieferten [Future] versetzt die Aufgabe in den Zustand [CANCELLED] und unterbricht den Thread, der sie ausführt ([cancel(false)] verhindert lediglich, dass die Aufgabe startet, falls sie noch nicht begonnen hat). Nach dem Abbruch löst [get()] eine [CancellationException] aus.
Der Mechanismus ist kooperativ: Niemand stoppt eine Operation zwangsweise; die Operation hält sich selbst an einer Stelle an, an der sie dies sauber tun kann. Deshalb darf eine Methode, die eine [InterruptedException] abfängt, sie nicht ignorieren: Sie muss sie entweder weitergeben, sich selbst beenden oder zumindest das Flag mit [Thread.currentThread().interrupt()] wieder setzen, damit der aufrufende Code weiß, dass eine Unterbrechung angefordert wurde (das tut unsere Methode [sleep]).
Das Programm [Async13.java] bricht einen simulierten Download auf mehrere Arten ab:
Ergebnisse:
Kommentare:
- Zeilen 47–58: Der simulierte Download erhält alle 300 ms einen Block. Er wird von einem virtuellen Thread ausgeführt und verwendet ein blockierendes Warten, [Thread.sleep], das endet, sobald der Thread unterbrochen wird: [InterruptedException] verlässt die Schleife, und der Download hält an und signalisiert dies. Er benötigt keine besonderen Parameter, um abbrechbar zu sein: Die Wartevorgänge von [java.util.concurrent] reagieren in gleicher Weise auf die Unterbrechung, ebenso wie in einem virtuellen Thread die blockierenden E/A-Operationen auf Sockets (der Socket wird dann geschlossen, und die Operation löst eine [SocketException] aus);
- Zeilen 6–14: [get(1200, TimeUnit.MILLISECONDS)] wartet höchstens 1,2 Sekunden auf das Ergebnis und löst dann eine [TimeoutException] aus. Das Warten wird aufgegeben, nicht aber die Operation: Sie wird ausdrücklich mit [cancel(true)] abgebrochen, was den virtuellen Thread des Downloads unterbricht. Der Thread hat drei Blöcke empfangen und hält bei 1.200 ms an (Zeilen 2–6 der Ergebnisse);
- Zeilen 16–26: eine abbrechbare Berechnung (kein Warten). Die Methode [compute] (Zeilen 60–71) prüft das Unterbrechungsflag ihres Threads alle eine Million Durchläufe und hält an, wenn es gesetzt ist. Das Programm bricht sie nach 300 ms ab: [get()] löst sofort eine [CancellationException] aus (Zeile 7), und die Berechnung hält kurz darauf von selbst an (Zeile 8);
- Zeilen 28–35: Das Programm fordert den Abbruch nach 700 ms an. Er wirkt sofort: Das Warten auf den dritten Block wird unterbrochen (Zeilen 11–13);
- Zeilen 37–43: eine Falle, die man kennen sollte. Die Methode
*[cancel]eines*[CompletableFuture]beendet diesen im Zustand*[CANCELLED], unterbricht aber nichts: Ein [CompletableFuture] weiß nicht, welcher Thread, falls überhaupt einer, für ihn arbeitet (sein Parameter [mayInterruptIfRunning] wird ignoriert). Der Download läuft bis zum Ende weiter (Zeilen 16–17); nur sein Ergebnis wird ignoriert. Damit ein [CompletableFuture] die Operation, die er darstellt, anhalten kann, muss diese Operation den Zustand des [CompletableFuture] überwachen ([isCancelled()]), oder der [Future]* bzw. der Thread der Aufgabe muss aufbewahrt werden, um ihn zu unterbrechen; - Zeile 44: Die Methode [close()] des Executors wartet auf den Abschluss aller Aufgaben, einschließlich der aus Schritt 4.
9.6.2. Mehrere Vorgänge, mehrere Ausgänge
Das Programm [Async14.java] startet fünf Vorgänge, die 1 bis 5 Sekunden dauern: Vorgang Nr. 3 löst eine Ausnahme aus, und Vorgang Nr. 4 wird abgebrochen. Es verarbeitet jede Aufgabe, sobald sie beendet ist, unabhängig davon, wie sie endete, und weiß immer, um welche Aufgabe es sich handelt:
Ergebnisse:
Kommentare:
- Zeilen 36–48: der Vorgang. Nr. 3 löst eine Ausnahme aus; die anderen „schlafen“ [duration] Sekunden lang in Schritten von einer Sekunde, mit einem unterbrechbaren [Thread.sleep], und liefern ein Ergebnis – einen [record] –, das die vorgesehene Dauer und die tatsächliche Dauer enthält. Die Methode deklariert [InterruptedException]: Sie wird von einem [Callable] aufgerufen, dessen Methode [call] geprüfte Ausnahmen auslösen kann;
- Zeilen 7–8: zwei Executors, die im selben [try] deklariert sind: der Executor für virtuelle Threads und ein [ScheduledExecutorService], ein Executor, der eine Aufgabe nach einer Verzögerung ausführen kann (darauf kommen wir im Abschnitt über die Zeit zurück);
- Zeilen 10–15: Die fünf Vorgänge werden an den [CompletionService] übergeben, den wir bereits in [Async10.java] kennengelernt haben, und ihre [Future]-Instanzen werden in einer Liste gespeichert;
- Zeile 17: [ScheduledExecutorService] bricht Vorgang Nr. 4 nach 2,5 Sekunden ab, obwohl dieser noch 2,5 Sekunden hätte laufen sollen;
- Zeilen 21–32: [take()] liefert jeden Vorgang, sobald er abgeschlossen ist, unabhängig davon, wie er endete: Auch ein abgebrochener [Future] wird geliefert. Wir rufen nicht [get()] auf, was eine Ausnahme auslösen würde, sondern untersuchen den Zustand des [Future] mit einem [switch]-Ausdruck, der die vier Konstanten von [Future.State] abdeckt (der Compiler prüft, dass keine fehlt). Die Nummer des Vorgangs ergibt sich aus der Position seines [Future] in der Liste ([indexOf]);
- Die Ergebnisse zeigen, dass Nr. 3 sofort fehlschlägt, dass Nr. 0, 1 und 2 nach 1, 2 bzw. 3 Sekunden enden und dass Nr. 4 nach 2,5 Sekunden abgebrochen wird.
9.6.3. Die Dauer eines Wartens begrenzen
Das Programm [Async15.java] stellt Werkzeuge zur Begrenzung der Wartedauer vor: die Methoden [orTimeout] und [completeOnTimeout] von [CompletableFuture] (Java 9) sowie die Methode [get] mit einer Frist von [Future]. Es zeigt außerdem, wie man zwei Abbruchursachen kombiniert.
Ergebnisse:
Kommentare:
- Zeilen 7–8: Die langsame Operation ist eine blockierende Methode (Zeilen 69–79), die von einem virtuellen Thread ausgeführt wird, und zwar mit [supplyAsync] und einem Executor;
- Zeile 10: [orTimeout(timeout, unit)] beendet den [CompletableFuture] mit einer [TimeoutException] , wenn er nicht innerhalb der Frist abgeschlossen ist. Das ist die direkte Schreibweise des „Rennens“ mit [anyOf] aus dem Programm [Async09.java]. [orTimeout] erzeugt keinen neuen [CompletableFuture]: Es verändert den, auf den es angewendet wird (und gibt ihn zurück); deshalb ist der Zustand von [slow] ist [FAILED] (Zeile 2 der Ergebnisse);
- Zeilen 14–15: [orTimeout] bricht das Warten ab, nicht die Operation: Der virtuelle Thread läuft weiter und beendet seine Arbeit nach 3 Sekunden (Zeile 3), ohne dass es etwas nützt. Das ist dasselbe Problem wie zuvor bei [cancel]: Ein [CompletableFuture] kann die Operation, die er darstellt, nicht unterbrechen;
- Zeilen 17–22: [completeOnTimeout(value, timeout, unit)] beendet den [CompletableFuture] mit einem Standardwert, wenn er nicht innerhalb der Frist abgeschlossen ist: Nach einer Sekunde wird eine „Standardantwort“ geliefert (Zeile 4);
- Zeilen 24–32: Um die Operation wirklich anzuhalten, wird sie an den Executor übergeben; wir warten höchstens eine Sekunde auf ihren [Future] und brechen sie dann mit [cancel(true)] ab, was ihren Thread unterbricht: Die Operation hält nach 1 Sekunde an (Zeilen 5–6). Dies ist die bevorzugte Lösung, wenn die Operation blockierend und unterbrechbar ist;
- Zeilen 49–61: Ein Vorgang kann aus mehreren Gründen angehalten werden; hier durch seine eigene Zeitüberschreitung und eine allgemeine Stoppanforderung des Aufrufers:
- Zeile 51: Die eigene Zeitüberschreitung des Vorgangs wird mit [orTimeout] festgelegt;
- Zeile 53: Der allgemeine Abbruch ist selbst ein [CompletableFuture<Void>], den der Aufrufer beenden wird; an ihn ist eine Fortsetzung angehängt, die das Warten auf die Antwort abbricht;
- Zeilen 55–60: Unabhängig von der Ursache endet das Warten mit einem Fehlschlag; [handle] prüft mit einem [switch] über die Typen (Java 21) auf eine Ausnahme: [case null] für Erfolg, [case TimeoutException _] für die Zeitüberschreitung, [case CancellationException _] für den allgemeinen Abbruch. Das Zeichen [_] (Java 22) ist eine anonyme Variable: Der Typ wird getestet, ohne dass das Objekt benannt werden muss;
- Zeilen 36–46: drei Vorgänge und ein allgemeiner Abbruch, der bei 1.200 ms angefordert wird, sobald [CompletableFuture] und [generalStop] abgeschlossen sind. Der Vorgang [fast] endet normal; der Vorgang [slow] überschreitet seine Frist von einer Sekunde; der Vorgang [medium], dem zwei Sekunden zugestanden wurden, wird durch den allgemeinen Abbruch beendet (Zeilen 7–10).
9.7. Fortschritt melden
Eine lang laufende Operation muss oft ihren Fortschritt melden (eine Fortschrittsanzeige, ein Prozentwert). Am einfachsten übergibt man ihr eine Callback-Funktion , die die Fortschrittsmeldungen erhält: einen [Consumer<T>], das funktionale Interface aus Kapitel 7, dessen einzige Methode [accept(T)], einen Wert entgegennimmt. Die Operation ruft [accept] bei jedem Schritt auf; sie weiß nicht, wie die Fortschrittsmeldungen dargestellt werden.
In einer grafischen Benutzeroberfläche können die Meldungen – die vom Thread erzeugt werden, der die Operation ausführt – die grafischen Komponenten nicht direkt aktualisieren: [Consumer] muss die Aktualisierung an den UI-Thread delegieren ([SwingUtilities.invokeLater(() -> bar.setValue(percentage))] mit Swing, [Platform.runLater] mit JavaFX). In einem Konsolenprogramm kann er die Ausgabe direkt anzeigen. Das Programm [Async16.java] simuliert einen Kopiervorgang, den der Benutzer durch Eingabe von [Enter] abbrechen kann:
Ergebnisse ohne Abbruch:
Ergebnisse, wenn der Benutzer während des Kopiervorgangs nach etwa eineinhalb Sekunden [Enter] eingibt:
Kommentare:
- Zeilen 24–35: Die Operation erhält einen [Consumer<Progress>]. Nach jeder Datei meldet sie ihren Fortschritt mit einem [Progress]-Objekt (einem [record] , das den Prozentwert und den Dateinamen enthält). Ein Aufrufer, der keine Meldungen wünscht, übergibt [null], daher die Prüfung in Zeile 30;
- Zeilen 41–46: die Anzeige einer Meldung: ein Balken aus 20 Zeichen, der mit [String.repeat] (Java 11) erstellt wird. Die Methodenreferenz [this::display] (Zeile 6) ist der [Consumer<Progress>] , der an die Operation übergeben wird;
- Zeile 6: Das Kopieren wird von einem virtuellen Thread ausgeführt;
- Zeilen 8–13: ein weiterer virtueller Thread wartet darauf, dass der Benutzer [Enter] eingibt ([IO.readln()] ist ein blockierendes Lesen, weshalb dafür ein eigener Thread verwendet wird: Blockiert ist dieser Thread, nicht das Programm), und bricht dann das Kopieren mit [cancel(true)] ab, was das [Thread.sleep] in Zeile 28 unterbricht. Das Programm wartet nicht auf ihn: Es ist ein Daemon-Thread, der am Programmende aufgegeben wird, wenn der Benutzer nichts eingegeben hat;
- Zeilen 14–20: Das Programm wartet auf das Ende des Kopierens. Ein Abbruch führt zu einer [CancellationException], ein Fehler beim Kopieren dagegen zu einer [ExecutionException].
9.8. Asynchrone Ein-/Ausgabe
9.8.1. Dateien
E/A ist der eigentliche Grund für die asynchrone Verarbeitung. Java stellt für Dateien zwei Klassenfamilien bereit:
- die „klassischen“, blockierenden Klassen: [Files] ([readAllLines], [readString], [lines], [writeString], [newBufferedReader], [newBufferedWriter] …), [BufferedReader], [BufferedWriter]. Sie werden heute in einem virtuellen Thread ausgeführt, wenn man einen wichtigen Thread nicht blockieren möchte;
- die Klasse [AsynchronousFileChannel] (Java 7), deren Operationen einen [Future] liefern oder einen [CompletionHandler] aufrufen. Sie wird selten verwendet: Unter Linux führt sie tatsächlich blockierende Lesevorgänge in einem internen Thread-Pool der JVM aus, und ihre Schnittstelle ist umständlich.
Das Programm [Async17.java] zeigt beide Familien, indem es die Datei mit den Steuerstufen aus dem Hauptprogramm liest, [TaxData.txt], die im Verzeichnis des Programms liegt:
Jede Zeile enthält die Schwelle der Stufe, den Koeffizienten [coeffR] und den Koeffizienten [coeffN], getrennt durch das Zeichen [:] und mit Dezimalpunkt geschrieben (der Steuertarif ist der Tarif von 2004 für die Einkünfte von 2003 und wird für diese Übung unverändert beibehalten). Das Programm läuft im Ordner [09-async] und sucht seine Dateien im aktuellen Ordner.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | |
Ergebnisse:
Kommentare:
- Zeilen 20–44: Lesen mit einem [AsynchronousFileChannel], dargestellt in Form eines [CompletableFuture<String>]. Dies ist die allgemeine Technik, um eine API mit Callback-Methoden in einen [CompletableFuture] umzuwandeln: Wir erzeugen einen „in Arbeit befindlichen“ [CompletableFuture] (Zeile 22), geben ihn sofort zurück (Zeile 43), und die Callback-Methoden schließen ihn ab, indem sie entweder das Ergebnis ([complete], Zeile 30) oder die Ausnahme ([completeExceptionally], Zeile 35) übergeben. Das Callback-Objekt ist eine anonyme Klasse, die [CompletionHandler<Integer, ByteBuffer>] implementiert: Das Ergebnis einer Leseoperation ist die Anzahl der gelesenen Bytes, und das hier übergebene Objekt ist der Puffer selbst. Eine einzelne Leseoperation genügt für eine kleine Datei; eine große Datei würde aufeinanderfolgende Leseoperationen erfordern, die die Callback-Methoden verketten müssten;
- Zeile 39: [whenComplete] schließt den Kanal, wenn die Leseoperation beendet ist, ob erfolgreich oder nicht;
- Zeilen 11–17: Die übrigen Operationen sind gewöhnliche blockierende E/A-Operationen, die in der Methode [processFiles] zusammengefasst und von einem virtuellen Thread ausgeführt werden. Das Lambda eines [Runnable] kann keine geprüfte Ausnahme auslösen: Die [IOException] wird innerhalb des Lambdas abgefangen;
- Zeile 48: [Files.readAllLines] liest die gesamte Datei und liefert eine Liste ihrer Zeilen (standardmäßig in UTF-8, wie alle Methoden von [Files]);
- Zeilen 52–59: zeilenweises Lesen mit einem [BufferedReader]; [readLine()] liefert am Dateiende [null] . Jede Zeile wird in [TaxBracket] mit der Methode [parse] des Records umgewandelt (Zeilen 100–107); die Zahlen sind [BigDecimal], dessen Konstruktor unabhängig von der Sprache des Rechners einen Dezimalpunkt erwartet. Die von der Methode [toString]erzeugte Darstellung eines Records erscheint in Zeile 4 der Ergebnisse;
- Zeilen 63–65: [Files.lines] liefert einen [Stream<String>] aus bei Bedarf gelesenen Zeilen: Anders als [readAllLines] lädt er nicht die gesamte Datei in den Speicher. Dies ist die bevorzugte Methode für große Dateien. Der Stream hält die Datei geöffnet: Er muss geschlossen werden, daher das [try] mit Ressource;
- Zeilen 68–79: Schreiben mit einem [BufferedWriter], der beim Verlassen des [try] geschlossen (und damit auf die Platte geschrieben) wird. Das Format [%,d] fügt das Tausendertrennzeichen der Sprache des Rechners ein (im Französischen ein schmales geschütztes Leerzeichen);
- Zeilen 82–88: [Files.readString] (Java 11) liest die geschriebene Datei erneut ein; [Files.writeString], mit der Option [StandardOpenOption.APPEND], fügt ihr eine Zeile hinzu; [getLast()] (Java 21) liefert das letzte Element der Liste, danach wird die Datei gelöscht.
Erinnern Sie sich an die oben genannte Einschränkung: Lese- und Schreibzugriffe auf Dateien pinnen den virtuellen Thread während der Operation an seinen Carrier-Thread, und die JVM kompensiert dies, indem sie einen Carrier-Thread hinzufügt. Bei lokalen Dateien fällt das selten auf; bei Netzwerkoperationen geben virtuelle Threads ihre Carrier beim Warten tatsächlich frei.
9.8.2. Netzwerk: HttpClient
Der HTTP-Client von Java, [java.net.http.HttpClient] (Java 11), bietet beide Ansätze: [send], das blockierend ist und die Antwort liefert, und [sendAsync], das sofort einen [CompletableFuture] mit der Antwort liefert. Kapitel 12 wird dies im Detail behandeln; das Programm [Async18.java] vergleicht lediglich die beiden Methoden, indem es einen kleinen lokalen HTTP-Server abfragt, der eine Sekunde benötigt, um die „Temperatur“ einer Stadt zu liefern:
Ergebnisse:
Kommentare:
- Zeilen 12–27: der Server. Die JVM-Datei enthält einen kleinen HTTP-Server, die Klasse [HttpServer] aus dem Modul [jdk.httpserver], die in Zeile 2 importiert wird (eine kompakte Datei importiert automatisch nur das Modul [java.base]; die Client-Klassen aus dem Modul [java.net.http] werden in den Zeilen 3–5 importiert). [createContext] verknüpft einen Handler mit dem Pfad [/temperature] – ein Lambda, das den HTTP-Austausch erhält: Es dekodiert den Parameter [city] aus der angeforderten Adresse, wartet eine Sekunde und sendet dann die Antwort. Zeile 26 lässt jede Anfrage von einem virtuellen Thread bearbeiten: Ein so konfigurierter Server kann Tausende wartender Clients bedienen;
- Zeilen 29–31: Der Client wird von einem Konstruktor ([newBuilder]) erzeugt, der hier die Protokollversion festlegt. Seit Java 21 implementiert er [AutoCloseable] und wird in einem [try] mit Ressource deklariert. Eine erste Anfrage dient dazu, die JVM „aufzuwärmen“: Bei der ersten Verwendung eines Clients werden zahlreiche Klassen geladen, was die nachfolgende Messung um einige hundert Millisekunden verfälschen würde;
- Zeilen 33–40: [sendAsync(request, handler)] sendet die Anfrage und liefert sofort einen [CompletableFuture<HttpResponse<String>>]; der Body-Handler [BodyHandlers.ofString()] gibt an, dass der Antwortkörper als Zeichenkette gelesen werden soll. [thenApply(HttpResponse::body)] behält nur den Körper. Die sechs Anfragen werden gleichzeitig gesendet, und ihre Antworten treffen gemeinsam nach einer Sekunde ein (Zeile 2 der Ergebnisse). Während des Wartens wartet kein Thread auf die Antwort: Der Client überwacht seine Verbindungen mit einem „Selector“-Thread;
- Zeilen 42–55: [send] ist blockierend; es wird aus sechs virtuellen Threads aufgerufen. Das Ergebnis ist dasselbe: eine Sekunde für alle sechs Anfragen (Zeile 3), und es werden keine Systemthreads blockiert;
- Zeilen 61–66: die GET-Anfrage. [URLEncoder.encode] kodiert Zeichen, die nicht unverändert in einer Adresse vorkommen dürfen (das [É] von Évry), und der Server dekodiert sie mit [URLDecoder.decode] (Zeile 17).
9.9. Asynchrone Wertströme
Eine asynchrone Operation liefert nach einer gewissen Zeit ein Ergebnis. Ein Stream ([Stream]) oder ein Iterator liefert eine Folge von Werten, die bei Bedarf erzeugt werden. Manchmal müssen beide kombiniert werden: eine Folge von Werten, bei der vor der Erzeugung jedes Werts gewartet werden muss. Das ist der Fall bei den Zeilen einer großen Datei, den Zeilen im Ergebnis einer SQL-Abfrage, den Nachrichten, die über eine Netzwerkverbindung eintreffen, den Messwerten von Sensoren … Andere Sprachen haben dafür einen eigenen Typ; Java bietet zwei Modelle:
- das „Pull“-Modell: Der Verbraucher fordert den nächsten Wert an und wartet, bis er verfügbar ist. Mit virtuellen Threads ist dies einfach ein [Iterator] oder ein [Stream] , bei dem die Erzeugung jedes Werts blockiert und der von einem virtuellen Thread gelesen wird;
- das „Push“-Modell: Der Erzeuger sendet die Werte an seine Abonnenten, sobald sie erzeugt werden, und die Abonnenten steuern den Durchsatz. Dies ist das Modell der reaktiven Streams, standardisiert durch die Interfaces von [java.util.concurrent.Flow] (Java 9).
9.9.1. Das Pull-Modell: ein Stream, der von einem virtuellen Thread gelesen wird
Das Programm [Async19.java] erzeugt Messwerte – einen alle 200 ms – in Form eines [Stream<Measurement>]:
Ergebnisse:
Kommentare:
- Zeilen 52–62: der Erzeuger. Er liefert einen [Stream<Measurement>] , der aus den ganzen Zahlen von 1 bis [count] gebildet wird; die Funktion [mapToObj] wartet 200 ms und liefert dann einen Messwert. Da ein Stream lazy ist, wird diese Funktion nur aufgerufen, wenn der Verbraucher den nächsten Wert anfordert, und jeder Messwert wird verarbeitet, bevor der nächste erzeugt wird. [onClose] registriert eine Aktion, die beim Schließen des Streams ausgeführt wird, unabhängig vom Grund: Das ist das [finally] des Erzeugers;
- Zeile 6: Die gesamte Arbeit wird von einem virtuellen Thread erledigt: Das Warten von 200 ms auf jeden Messwert blockiert keinen Systemthread;
- Zeilen 11–14: Jeder Messwert wird verarbeitet, sobald er erzeugt wird: einer alle 200 ms (Zeilen 2–5 der Ergebnisse). Der Stream wird in einem [try] mit Ressource deklariert: Sein Schließen löst die Aktion [onClose] aus (Zeile 6);
- Zeilen 16–27: Um die Schleife vor ihrem Ende zu verlassen, wird der Stream mit seinem Iterator durchlaufen. Nach dem [break] erzeugt der Erzeuger die restlichen 96 Messwerte nicht mehr, und der Stream wird beim Verlassen des [try] geschlossen (Zeile 11). Die Methoden [takeWhile] (Java 9) oder [limit] erlauben es ebenfalls, einen Stream anzuhalten;
- Zeilen 29–38: Abbruch. Der Stream wird von einem anderen virtuellen Thread gelesen, den die Methode [waitForEnd] (Zeilen 64–73) nach 700 ms unterbricht. Das Warten auf den vierten Messwert wird unterbrochen: Die Methode [sleep] löst eine [CancellationException] aus, die den Stream durchläuft; das [try] mit Ressource schließt den Stream (Zeile 15 der Ergebnisse), danach meldet das [catch] den Abbruch (Zeile 16);
- Zeilen 40–49: Alles, was die Stream-API kann, wird auf den Stream angewendet: Filtern, Transformieren, Sammeln. Das Ergebnis liegt erst am Ende des Streams vor, nach 6 × 200 ms;
- Zeilen 90–96: Die Methode [toString] des Records [Measurement] wird für eine kompaktere Anzeige neu definiert; [NumberFormat.getInstance()] formatiert die reelle Zahl gemäß der Sprache des Rechners, ohne überflüssige Dezimalstellen ([21], [21.75]).
Dasselbe Muster gilt für einen [BufferedReader] (seine Zeilen werden bei Bedarf gelesen, und seine Methode [lines()] liefert einen [Stream<String>]), für ein [ResultSet] von JDBC oder für den eingehenden Stream eines Sockets: Auf einem virtuellen Thread ist ein blockierender Stream ein asynchroner Stream.
9.9.2. Das Push-Modell: Flow und SubmissionPublisher
Das Interface [java.util.concurrent.Flow] (Java 9) fasst vier innere Interfaces zusammen, die reaktive Streams standardisieren:
- [Flow.Publisher<T>], der Publisher, erzeugt Werte; mit seiner Methode [subscribe] wird ihm ein Subscriber hinzugefügt;
- [Flow.Subscriber<T>], der Subscriber, erhält Werte über seine Methode [onNext], das Ende des Streams über [onComplete], einen Fehler über [onError] und zu Beginn das Objekt [Flow.Subscription], das ihn über [onSubscribe] mit dem Publisher verbindet;
- [Flow.Subscription], das Abonnement: [request(n)] fordert zusätzliche Werte an, bis zu [n], und [cancel()] beendet das Abonnement. Der Publisher sendet nie mehr Werte, als der Subscriber angefordert hat: Das ist der „Backpressure“, der verhindert, dass ein schneller Publisher einen langsamen Subscriber überfordert;
- [Flow.Processor<T, R>] ist zugleich Subscriber und Publisher (ein Transformationsknoten).
Java stellt eine Implementierung des Publishers bereit, [SubmissionPublisher<T>], der die Werte über einen Executor und einen für jeden Subscriber eigenen Puffer an jeden Subscriber ausliefert. Reaktive Bibliotheken (Project Reactor, RxJava) implementieren dieselben Interfaces und ergänzen sie um Dutzende von Operatoren. Das Programm [Async20.java] veröffentlicht sechs Messwerte an zwei Subscriber: eine schnelle Anzeige, die sich abmeldet, wenn die Temperatur 22 °C überschreitet, und ein langsames Archiv:
Ergebnisse:
Kommentare:
- Zeilen 26–70: der Subscriber, der jeden Messwert in [duration] Millisekunden verarbeitet und sich abmeldet, wenn der Messwert [threshold] erreicht:
- Zeilen 40–45: [onSubscribe] erhält das Abonnement und fordert einen ersten Wert an;
- Zeilen 47–57: [onNext] verarbeitet einen Wert und fordert dann entweder einen weiteren an ([request(1)]) oder beendet das Abonnement ([cancel()]). Indem er die Werte einzeln anfordert, steuert der Subscriber die Datenrate selbst;
- Zeilen 59–69: [onError] und [onComplete] signalisieren das Ende des Streams, entweder aufgrund eines Fehlers oder normal. [CountDownLatch] ermöglicht es dem Hauptprogramm, auf dieses Ende zu warten;
- Zeile 9: Der Publisher liefert die Werte an jeden Subscriber über eine Aufgabe des angegebenen Executors aus – hier virtuelle Threads (ohne Executor würde er den gemeinsamen Pool verwenden, in dem das Warten auf das Archiv einen seiner wenigen Threads blockieren würde) – und hält für jeden Subscriber einen Puffer von bis zu 2 Werten vor;
- Zeilen 12–17: Der Publisher veröffentlicht alle 200 ms mit [submit] einen Messwert; die Methode liefert eine Schätzung der Verzögerung: die größte Anzahl von Werten, die veröffentlicht, aber von einem Subscriber noch nicht verarbeitet wurden. Ist der Puffer eines Subscribers voll, wartet [submit] darauf, dass ein Platz frei wird: Der Messwert Nr. 5, der etwa bei 1.070 ms bereit ist, wird erst bei 1.271 ms veröffentlicht (Zeile 14 der Ergebnisse), wenn das Archiv den Messwert Nr. 3 verarbeitet hat. Das ist Backpressure: Der Publisher wird auf das Tempo des langsamsten Subscribers gebremst. ([SubmissionPublisher] bietet außerdem [offer], womit ein Wert verworfen werden kann, statt zu warten);
- Die Ergebnisse zeigen, dass die Anzeige, die schnell ist, jeden Messwert verarbeitet, sobald er veröffentlicht wird, und sich bei Messwert Nr. 4 abmeldet (22,5 °C, Zeilen 11–12), während das Archiv, das 500 ms pro Messwert benötigt, zurückfällt und alle sechs Messwerte erhält;
- Zeilen 18–22: [close()] signalisiert das Ende des Streams: Jeder noch angemeldete Subscriber erhält [onComplete] , nachdem er die Werte in seinem Puffer verarbeitet hat (Zeile 20). Das Programm wartet mit dem [CountDownLatch] auf das Ende des Archivs.
Das Push-Modell eignet sich für Quellen, die Daten in ihrem eigenen Tempo erzeugen (Sensoren, Ereignisse, Nachrichten), und für reaktive Verarbeitungsketten; das Pull-Modell, das einfacher zu schreiben und zu lesen ist, eignet sich für das Lesen aus einer Quelle bei Bedarf. Mit virtuellen Threads genügt in der Regel das Pull-Modell.
9.10. Cache, Rückkehr zum richtigen Thread und die Operation selbst beenden
9.10.1. Ein Cache für asynchrone Operationen
Ein [CompletableFuture] ist ein Objekt: Jeder Aufruf einer Methode, die einen solchen liefert, reserviert mindestens ein Objekt auf dem Heap, das der Garbage Collector wieder freigeben muss. Das ist bei E/A, die Millisekunden dauert, vernachlässigbar, und die aktuellen Garbage Collectors der JVM verarbeiten kurzlebige Objekte sehr effizient: Java hat keine „leichtgewichtige“ Variante von [CompletableFuture] (andere Sprachen haben eine, für asynchrone Methoden, die millionenfach aufgerufen werden und meist schon über ihr Ergebnis verfügen).
Für eine asynchrone Methode, die oft bereits über das Ergebnis verfügt, empfiehlt es sich, die [CompletableFuture] -Objekte selbst zwischenzuspeichern: Ein bereits bekannter Wert wird von einem bereits abgeschlossenen [CompletableFuture] ohne neue Allokation geliefert, und mehrere gleichzeitige Anfragen für denselben Wert teilen sich dieselbe laufende Operation. Das Programm [Async21.java] wendet dies auf einen Wechselkursdienst an:
Ergebnisse:
Kommentare:
- Zeile 30: Der Cache ordnet jedem Währungscode den [CompletableFuture] für seinen Wechselkurs zu, ob abgeschlossen oder noch in Arbeit. Es handelt sich um eine [ConcurrentHashMap] (Kapitel 8), da sie von mehreren Threads gleichzeitig benutzt werden kann (dem Hauptthread und dem Timer-Thread, der die Lesevorgänge abschließt);
- Zeilen 34–38: [computeIfAbsent(key, function)] liefert den dem Schlüssel zugeordneten Wert, falls er existiert; andernfalls ruft es die Funktion auf, speichert deren Ergebnis im Dictionary und liefert es zurück. Bei einer [ConcurrentHashMap] ist diese Operation atomar: Zwei Threads, die gleichzeitig eine nicht vorhandene Währung anfordern, lösen nur einen einzigen Serverzugriff aus;
- Zeilen 40–58: die simulierte Serverabfrage (300 ms). Die Fortsetzung [thenApply] enthält einen [switch]-Ausdruck über eine Zeichenkette, dessen Zweig [default] bei einer unbekannten Währung eine Ausnahme auslöst;
- Zeilen 52–57: Im Fehlerfall wird die Operation aus dem Cache entfernt, damit eine spätere Anfrage für dieselbe Währung den Server erneut abfragt, statt unbegrenzt denselben Fehlschlag zu liefern. Im Cache gespeichert wird der [CompletableFuture] , den [whenComplete] zurückgibt: Er wird erst abgeschlossen, nachdem die Aktion ausgeführt wurde, was dem Aufrufer garantiert, dass der Cache aktuell ist, wenn er das Ergebnis erhält;
- Zeilen 5–11: Für den Aufrufer ändert sich nichts: Er wartet mit [join()] auf das Ergebnis. Die Ergebnisse zeigen die drei Serverzugriffe (je 300 ms; beim ersten etwas länger, da die JVM währenddessen die benötigten Klassen lädt) und die vier sofortigen Antworten aus dem Cache;
- Zeilen 13–18: Drei gleichzeitige Anfragen für den Wechselkurs des Schweizer Frankens erhalten dasselbe Objekt und führen zu nur einem Serverzugriff (Zeile 10 der Ergebnisse);
- Zeilen 20–25: Die unbekannte Währung führte zu einem Fehlschlag und befindet sich nicht mehr im Cache (Zeile 11).
9.10.2. Rückkehr zum GUI-Thread
Das Programm [Async06.java] hat gezeigt, dass eine Fortsetzung je nach Fall entweder von dem Thread, der die Operation abschließt, oder von einem Thread des gewählten Executors ausgeführt wird. In einer grafischen Anwendung (Swing, JavaFX) ist das wichtig: Eine grafische Komponente darf nur vom UI-Thread manipuliert werden. Java hat keinen Mechanismus, der den Rest des Codes automatisch zu diesem Thread zurückführt; das Programm muss dies selbst veranlassen, entweder indem es der Fortsetzung den richtigen Executor übergibt oder indem es die Werkzeuge der Grafikbibliothek verwendet:
- Mit Swing bewirkt
*[SwingUtilities.invokeLater(action)], dass die Aktion vom Thread der Oberfläche ausgeführt wird; die Methodenreferenz[SwingUtilities::invokeLater]kann als Executor für eine Fortsetzung dienen:[download.thenAcceptAsync(page -> textArea.setText(page), SwingUtilities::invokeLater)]******. Die Klasse [SwingWorker] stellt ebenfalls eine Methode bereit, [doInBackground], die von einem Hintergrund-Thread ausgeführt wird, sowie die Methoden [process] und [done]*, die vom Thread der Oberfläche ausgeführt werden; - Mit JavaFX erfüllt [Platform.runLater(action)] denselben Zweck, und die Klassen [Task] und [Service] aus [javafx.concurrent] kapseln einen Hintergrundprozess samt seinem Fortschritt.
In allen Fällen gilt dieselbe Regel: Der UI-Thread darf niemals warten ([join()], [get()], blockierende E/A), sonst friert das Fenster ein. Die lang laufende Aufgabe wird von einem anderen Thread ausgeführt (zum Beispiel einem virtuellen Thread), und nur die abschließende Aktualisierung der Komponenten übernimmt der Thread der Oberfläche.
9.10.3. Einen CompletableFuture manuell beenden
Manchmal muss man eine API verwenden, die ihre Ereignisse über Listener meldet (Kapitel 7), während der übrige Code mit [CompletableFuture] geschrieben ist. Die Technik haben wir bei [Async17.java] gesehen: Man erzeugt mit dem Konstruktor einen „ausstehenden“ [CompletableFuture] , gibt ihn sofort zurück und beendet ihn selbst , wenn es nötig ist:
- [complete(value)] schließt ihn erfolgreich ab;
- [completeExceptionally(exception)] schließt ihn mit einem Fehler ab;
- [cancel(false)] bricht ihn ab.
Diese drei Methoden haben keine Wirkung, wenn der [CompletableFuture] bereits abgeschlossen ist ([complete] und [completeExceptionally] liefern dann [false]): Wer ihn zuerst abschließt, gewinnt, was Konkurrenzsituationen (etwa ein Ergebnis und eine Zeitüberschreitung, die gleichzeitig eintreffen) auf natürliche Weise löst. Das Programm [Async22.java] wartet darauf, dass ein Thermometer – das seine Listener bei jeder Messung benachrichtigt – eine bestimmte Temperatur erreicht:
Ergebnisse:
Kommentare:
- Zeilen 39–64: Das Thermometer, eine Klasse „alter Schule“: Ein [ScheduledExecutorService] erhöht die Temperatur alle 200 ms um 0,5 °C und übermittelt sie an seine Listener vom Typ [DoubleConsumer] (ein [Consumer] , der auf den Typ [double] spezialisiert ist). Die Liste der Listener ist eine [CopyOnWriteArrayList], eine Liste, die von einem Thread geändert werden kann (Hinzufügen oder Entfernen eines Listeners), während ein anderer Thread sie durchläuft;
- Zeilen 22–37: die Methode, die Benachrichtigungen in einen [CompletableFuture] umwandelt. Sie erzeugt einen temporären [CompletableFuture<Double>], registriert einen Listener beim Thermometer und liefert sofort den [CompletableFuture] zurück, der noch nicht abgeschlossen ist;
- Zeilen 27–31: Bei jeder Messung prüft der Listener den Schwellenwert. Ist er erreicht, beendet er den [CompletableFuture] mit der Temperatur als Ergebnis. Die folgenden Messungen rufen weiterhin [complete] auf, ohne Wirkung, bis der Listener entfernt wird;
- Zeile 34: Unabhängig davon, wie der [CompletableFuture] endet (Schwellenwert erreicht, Zeitüberschreitung, Abbruch durch den Aufrufer), entfernt [whenComplete] den Listener. Ohne dies bliebe ein Listener, dessen Schwellenwert nie erreicht wird, unbegrenzt registriert;
- Zeilen 8–18: Für den Aufrufer ist das Warten auf eine Temperatur eine asynchrone Operation wie jede andere: Er wartet mit [join()] darauf und setzt ihr mit [orTimeout] ein Zeitlimit. Da [orTimeout] den [CompletableFuture] selbst beendet (und nicht eine Kopie), wird die Aktion [whenComplete] in Zeile 34 ausgeführt, und der Listener wird entfernt.
Ein Warnhinweis: Die an einen [CompletableFuture] angehängten Fortsetzungen werden von dem Thread ausgeführt, der [complete] aufruft – hier dem Thread des Thermometers –, mitten in der Benachrichtigung seiner Listener. Sind diese Fortsetzungen langwierig, sollten sie mit den [xxxAsync]-Varianten und einem Executor geschrieben werden, oder der [CompletableFuture] sollte mit [completeAsync(() -> value, executor)] (Java 9) beendet werden, wodurch der Executor [complete] aufruft.
9.11. Begrenzte Parallelität
9.11.1. Virtuelle Threads und Semaphore
[allOf] und ein virtueller Thread pro Operation starten alle Operationen gleichzeitig. Das ist nicht immer wünschenswert: Um 10.000 Webseiten herunterzuladen, möchte man nicht 10.000 gleichzeitige Verbindungen zum selben Server öffnen. Bei Plattform-Threads wurde die Nebenläufigkeit durch die Größe des Thread-Pools begrenzt. Virtuelle Threads werden nicht gepoolt (sie sind so billig, dass pro Aufgabe einer erzeugt wird): Der Zugriff auf die knappe Ressource wird mit einem [Semaphore] (Kapitel 8) begrenzt, dessen Genehmigungen die Anzahl der erlaubten gleichzeitigen Operationen darstellen. Das Programm [Async23.java] lädt neun Seiten herunter, höchstens drei gleichzeitig:
Ergebnisse:
Kommentare:
- Zeile 10: ein Semaphor mit 3 Genehmigungen;
- Zeilen 13–24: ein virtueller Thread pro Seite. Die Aufgabe ist ein Lambda, das mit [return null;] endet: Es handelt sich also um einen [Callable], dessen Methode geprüfte Ausnahmen auslösen darf, wodurch hier die Behandlung von [InterruptedException], [acquire] und [Thread.sleep] entfällt;
- Zeilen 16–21: Jeder Thread wartet auf eine Genehmigung ([acquire]), lädt seine Seite herunter und gibt die Genehmigung dann zurück ([release]), und zwar in einem [finally], damit sie auch bei einem fehlgeschlagenen Download zurückgegeben wird. Ein virtueller Thread, der auf eine Genehmigung wartet, wird von seinem Host-Thread gelöst, genau wie bei einer E/A-Operation;
- Zeilen 29–37: Der Zähler [inProgress], der von den Threads gemeinsam genutzt wird, ist eine atomar veränderbare Version von [AtomicInteger];
- Die Ergebnisse zeigen drei Wellen von je drei Seiten: Sobald eine Seite fertig ist, beginnt eine andere, und die Anzahl der laufenden Downloads überschreitet nie 3. Der gesamte Vorgang dauert 3 Sekunden statt 9. Wenn zwei Threads fast gleichzeitig schreiben, kann die Reihenfolge der Zeilen von einer Ausführung zur nächsten variieren, und eine angezeigte Zeit kann sogar geringfügig früher liegen als die der vorherigen Zeile;
- Jede Seite hat ihren eigenen virtuellen Thread (Nr. 23 bis 33; die Nummern werden von allen Threads der JVM gemeinsam vergeben, einschließlich der Carrier-Threads, daher die Lücken), aber diese neun virtuellen Threads wurden von den einzigen zwei Carrier-Threads des Rechners ausgeführt.
9.11.2. Erzeuger / Verbraucher: BlockingQueue
Das vorige Kapitel hat das Modell Erzeuger/Verbraucher eingeführt: Erzeuger legen Elemente in eine Warteschlange, Verbraucher entnehmen sie. Das Interface [BlockingQueue<E>] ist das Werkzeug dafür: [put] legt ein Element in die Warteschlange und wartet – falls die Warteschlange begrenzt und voll ist – darauf, dass ein Platz frei wird; [take] entnimmt ein Element und wartet – falls die Warteschlange leer ist – darauf, dass eines eintrifft; [offer] und [poll] versuchen dasselbe ohne Warten (oder mit einer Frist). Diese Wartevorgänge sind blockierend; werden sie von virtuellen Threads ausgeführt, blockieren sie keinen Systemthread, und die blockierende Warteschlange wird zum Kommunikationsmittel zwischen asynchronen Operationen.
Das Programm [Async24.java] verarbeitet Bestellungen – die alle 50 ms erzeugt werden – mit zwei Verbrauchern, von denen jeder 400 ms für die Verarbeitung einer Bestellung benötigt:
Ergebnisse:
Kommentare:
- Zeile 5: eine [ArrayBlockingQueue] mit der Kapazität 2: Sie enthält höchstens 2 ausstehende Bestellungen;
- Zeilen 11–15: Der Erzeuger und die beiden Verbraucher werden von drei virtuellen Threads ausgeführt; das Programm wartet mit der Methode [close()] des Executors auf das Ende aller drei. Die Methoden [produce] und [consume] liefern [Void] und enden mit [return null;]: Die Lambdas in den Zeilen 12–14 sind daher [Callable], und die Methoden können [InterruptedException] deklarieren;
- Zeilen 19–37: Der Erzeuger versucht, jede Bestellung mit [offer] einzureihen. Ist die Warteschlange voll, meldet er dies und wartet mit [put] auf freien Platz: Der Erzeuger wird auf das Tempo der Verbraucher gedrosselt (Zeilen 8–9 der Ergebnisse). Das ist der Vorteil einer begrenzten Warteschlange: Ein zu schneller Erzeuger kann den Speicher nicht füllen;
- Zeile 34: Die Produktion ist beendet; der Erzeuger legt einen besonderen Wert ab, die Endemarke [END] (Zeile 3), die die Verbraucher erkennen werden. Eine blockierende Warteschlange hat nämlich keine Möglichkeit, zu signalisieren, dass sie „geschlossen“ ist;
- Zeilen 39–54: Jeder Verbraucher holt Bestellungen mit [take]. Eine Bestellung wird nur an einen Verbraucher ausgeliefert: Die Bestellungen werden je nach Verfügbarkeit auf C1 und C2 verteilt. Der Verbraucher, der die Endemarke erhält, legt sie für den anderen Verbraucher wieder in die Warteschlange und hält dann an;
- Wie im vorigen Beispiel können zwei fast gleichzeitig ausgegebene Zeilen in vertauschter Reihenfolge erscheinen.
9.12. Zeit: ScheduledExecutorService und Clock
Zwei Werkzeuge ergänzen die zeitbezogenen:
- Ein [ScheduledExecutorService] (Java 5) ist ein Executor, der eine Aufgabe nach einer Verzögerung ([schedule]) oder periodisch ausführen kann ([scheduleAtFixedRate], in festen Abständen, gemessen vom Beginn einer Ausführung bis zum Beginn der nächsten; [scheduleWithFixedDelay], mit einer festen Verzögerung zwischen dem Ende einer Ausführung und dem Beginn der nächsten). Eine periodische Aufgabe wird nie zweimal gleichzeitig ausgeführt: Dauert eine Ausführung länger als die Periode, wird die nächste verschoben. Einen Executor mit einem einzigen Thread erhält man mit [Executors.newSingleThreadScheduledExecutor()];
- Die abstrakte Klasse [java.time.Clock] (Java 8) stellt die Uhr dar: Sie liefert die aktuelle Zeit und die Zeitzone. [Clock.systemDefaultZone()] ist die Systemuhr in der Zeitzone des Rechners. Alle [now()]-Methoden der API [java.time] ([LocalDateTime.now(clock)], [Instant.now(clock)] …) akzeptieren eine Uhr. Eine Klasse, die von der Zeit abhängt, erhält eine [Clock] , statt [LocalDateTime.now()] aufzurufen: Sie lässt sich dann mit einer kontrollierten Uhr testen.
Das Programm [Async25.java] verwendet beide:
Ergebnisse:
Kommentare:
- Zeilen 8–11: [scheduleAtFixedRate(task, initialDelay, period, unit)] führt die Aufgabe zum ersten Mal nach 500 ms aus und danach alle 500 ms. Es liefert einen [ScheduledFuture] und einen [Future], mit dem sich unter anderem künftige Ausführungen abbrechen lassen. Der Zähler der Signaltöne ist ein [AtomicInteger]: Ein Lambda kann keine lokale Variable ändern;
- Zeilen 13–15: [schedule(task, delay, unit)] führt eine einzelne Aufgabe nach 2,2 Sekunden aus: Sie bricht die Signaltöne ab. [stop.get()] wartet auf das Ende dieser Aufgabe. Die Signaltöne erklangen bei 0,5, 1, 1,5 und 2 Sekunden, und der Timer hält nach 2,2 Sekunden an, nach 4 Signaltönen;
- Zeilen 30–38: Der Record [Reception] sagt je nach Uhrzeit „Guten Morgen“ oder „Guten Abend“. Er erhält seine Uhr von seinem Konstruktor, statt [LocalDateTime.now()] aufzurufen: Das ist eine injizierte Abhängigkeit, genau wie die [dao]-Schicht in Kapitel 6 in die [business]-Schicht injiziert wird;
- Zeilen 23–27: [Clock.fixed(instant, zone)] liefert eine angehaltene Uhr, die immer dieselbe Zeit anzeigt; so können wir das Verhalten von [Reception] am Morgen und am Abend prüfen, ohne bis zum Abend warten zu müssen. Die letzte Zeile verwendet die Systemuhr (das Ergebnis hängt also von der Ausführungszeit ab). Für anspruchsvollere Tests kann man eine eigene, von [Clock] abgeleitete Klasse schreiben, die man beliebig vorstellen kann. Das Interface [InstantSource] (Java 17), das nur die aktuelle Zeit liefert, ist eine noch leichtere Abhängigkeit, wenn die Zeitzone keine Rolle spielt.
Um eine Dauer zu messen, verwenden Sie nicht die Uhr (die während der Messung angepasst werden kann, zum Beispiel durch eine Synchronisierung der Systemzeit), sondern [System.nanoTime()], wie in den Beispielen dieses Kapitels gezeigt.
9.13. Strukturierte Nebenläufigkeit (Überblick)
In den bisherigen Beispielen laufen die von einem Programm gestarteten Operationen unabhängig von diesem: Schlägt eine fehl, laufen die anderen weiter; wird der Code, der sie gestartet hat, unterbrochen, laufen sie ebenfalls weiter; und nichts zwingt diesen Code, auf ihr Ende zu warten. Die strukturierte Nebenläufigkeit schlägt vor, eine Gruppe von Teilaufgaben als einen einzigen Block zu behandeln: Sie werden innerhalb eines Gültigkeitsbereichs (Scope) gestartet, der Scope wartet auf ihren Abschluss, und wenn eine fehlschlägt, werden die anderen abgebrochen. Die Klasse [StructuredTaskScope] setzt diese Idee mithilfe virtueller Threads um. Sie ist seit Java 21 verfügbar, befindet sich aber in Java 25 weiterhin im „Preview“-Status : Ihre API kann sich noch ändern, und ein Programm, das sie verwendet, muss mit der Option [--enable-preview] kompiliert und ausgeführt werden. Sie ist daher nicht Teil der Kursübungen; der folgende Code (Datei [preview/StructuredConcurrency.txt], zum Testen in eine Datei mit dem Namen [StructuredConcurrency.java] zu kopieren) vermittelt einen Eindruck von ihrer Funktionsweise:
Ergebnisse:
Kommentare:
- Zeile 8: [StructuredTaskScope.open()] öffnet einen Scope, der in einem [try] mit einer Ressource deklariert wird; sein Schließen stellt sicher, dass keine Teilaufgabe ihn überlebt;
- Zeilen 9–10: [fork] startet eine Teilaufgabe in einem neuen virtuellen Thread und liefert einen [Subtask] zurück;
- Zeile 13: [join()] wartet, bis alle Teilaufgaben beendet sind. Bei der Standardrichtlinie werden die anderen abgebrochen, wenn eine Teilaufgabe fehlschlägt, und [join()] löst eine Ausnahme aus;
- Zeile 14: die Ergebnisse der Teilaufgaben, die alle abgeschlossen sind;
- Zeilen 17–21: eine andere Richtlinie, bereitgestellt von [Joiner]: Die erste erfolgreiche Teilaufgabe liefert das Ergebnis von [join()], und die anderen werden abgebrochen. Dies ist das strukturierte Äquivalent zu [anyOf], wobei die unterlegenen Anfragen jedoch tatsächlich beendet werden.
9.14. Anwendung: Steuerberechnung mit virtuellen Threads
Das Programm [Async26.java] vereint mehrere Werkzeuge dieses Kapitels rund um die Steuerberechnung des Hauptthreads. Es liest die Steuerstufen aus der Datei [TaxData.txt], die bereits verwendet wurde, und liest eine Liste von Steuerzahlern aus der Datei [taxpayers.txt]:
(jede Zeile enthält: verheiratet [y/n], Anzahl der Kinder, Jahresgehalt), berechnet die Steuer jeder Person und schreibt die Ergebnisse in die Datei [results.txt]. Beide Lesevorgänge werden nebenläufig von virtuellen Threads ausgeführt, und der gesamte Ablauf ist auf 10 Sekunden begrenzt.
Ergebnisse:
Dasselbe Programm, ausgeführt in einem Ordner, in dem die Datei [TaxData.txt] fehlt:
Kommentare:
- Zeilen 11–14: Die beiden Eingabedateien werden gleichzeitig von zwei virtuellen Threads mit den üblichen blockierenden Lesemethoden gelesen ([Files.lines], [Files.readAllLines]);
- Zeilen 16–17: Die Berechnung ist eine dritte Aufgabe, die damit beginnt, mit [get()] auf den Abschluss der beiden Lesevorgänge zu warten. Diese Wartevorgänge blockieren einen virtuellen Thread, was keine Kosten verursacht;
- Zeilen 18–26: Das Hauptprogramm wartet bis zu 10 Sekunden auf das Ergebnis. Danach bricht es den Ablauf ab (wodurch dessen virtueller Thread beendet wird) und meldet den Fehler;
- Zeilen 27–36: Fehler werden an einer einzigen Stelle im Hauptprogramm behandelt. Ein Lesefehler (fehlende Datei, falsche Zahl) wird im [Future] der Leseoperation gespeichert; das [get()] der Berechnung wirft ihn erneut als [ExecutionException], die ihrerseits zur Ausnahme der Berechnung wird und vom [get] des Hauptprogramms erneut in eine zweite [ExecutionException] verpackt geworfen wird. Die Schleife in den Zeilen 30–32 verfolgt die Kette bis zur ursprünglichen Ursache zurück (zweites Ergebnis). Das ist der Nachteil abhängiger Aufgaben; die strukturierte Nebenläufigkeit, wie im vorigen Abschnitt beschrieben, beseitigt dieses Problem;
- Zeilen 39–44: Lesen der Steuerstufen mit einem [Stream] , der leere Zeilen überspringt;
- Zeilen 46–60: Verarbeitung der Steuerzahler. Jede Zeile wird durch den regulären Ausdruck in Zeile 5 validiert: ein [y] oder ein [n], gefolgt von zwei positiven ganzen Zahlen, getrennt durch Leerzeichen ([\s+]). Die Klammern definieren drei Gruppen, die [group(1)], [group(2)], und [group(3)] zurückliefern, sobald [matches()] geprüft hat, dass die gesamte Zeile dem Ausdruck entspricht. Eine fehlerhafte Zeile ([x] statt [y/n], negatives Gehalt) wird als solche gemeldet;
- Zeilen 62–77: Steuerberechnung mit [BigDecimal]. Die Division des Einkommens durch die Anzahl der Anteile ist unter Umständen nicht exakt: Sie erfolgt mit einer Genauigkeit von 16 signifikanten Stellen ([MathContext.DECIMAL64]). Die erste Steuerstufe, deren Schwellenwert größer oder gleich dem Familienquotienten ist, wird durch einen Stream ermittelt; [orElse(brackets.getLast())] liefert die letzte Stufe zurück, wenn keine passt. [intValue()] rundet die Steuer auf den nächsten ganzen Euro ab;
- die Ergebnisse liefern die Kontrollwerte für den roten Faden: 4.282 € für ein Ehepaar mit 2 Kindern und einem Gehalt von 60.000 €, 2.959 € mit 3 Kindern und 11.519 € für eine alleinstehende Person ohne Kinder.
Die Berechnung selbst ist synchron: Sie führt keine Ein-/Ausgabe durch und dauert einige Mikrosekunden. Es wäre sinnlos – und sogar schädlich –, sie auf einen anderen Thread auszulagern. Nur Aufgaben, die ein Warten beinhalten, werden asynchron gemacht.
9.15. Die goldenen Regeln
Fassen wir die Regeln der asynchronen Programmierung in Java zusammen:
- Zum Warten keinen System-Thread blockieren: Ein Wartevorgang (Ein-/Ausgabe, Timeout oder eine andere Operation) erfolgt entweder in einem virtuellen Thread oder indem eine Fortsetzung an ein [CompletableFuture] angehängt wird;
- Für neuen Code virtuelle Threads bevorzugen: blockierenden, sequenziellen und lesbaren Code schreiben (Schleifen, [try / catch], gewöhnliche lokale Variablen), ausgeführt von [Executors.newVirtualThreadPerTaskExecutor()]; ein virtueller Thread pro Aufgabe, niemals einen Pool virtueller Threads verwenden;
- [CompletableFuture] verwenden, um Operationen zu verknüpfen oder eine API zu nutzen, die [CompletableFuture] zurückliefert ([HttpClient.sendAsync], reaktive Bibliotheken); dann wählt man den Executor der Fortsetzung ([xxxAsync(..., executor)]) und führt niemals eine blockierende Operation im gemeinsamen Pool aus;
- Kein [join()] oder [get()] in einer Fortsetzung oder in einem GUI-Thread: Diese Wartevorgänge blockieren den Thread, der sie ausführt. Sie gehören ins Hauptprogramm oder in einen virtuellen Thread;
- Virtuelle Threads dienen dem Warten, nicht dem Rechnen: Für Berechnungen verwenden Sie einen Pool von Plattform-Threads, dessen Größe sich nach der Anzahl der Prozessoren richtet, oder parallele Streams;
- Den Zugriff auf knappe Ressourcen mit einem [Semaphore] begrenzen, nicht über die Größe eines Thread-Pools;
- Abbruch ist kooperativ: Eine Aufgabe wird über [Future.cancel(true)] abgebrochen, was ihren Thread unterbricht; eine unterbrochene Aufgabe beendet sich ordnungsgemäß; eine [InterruptedException] wird niemals verschluckt (sie wird entweder weitergereicht, oder das Interrupt-Flag wird wieder gesetzt). Und denken Sie daran, dass [CompletableFuture.cancel] nichts unterbricht;
- Wartezeiten begrenzen: [orTimeout], [completeOnTimeout], [get(timeout, unit)]; und die Operation selbst beenden, wenn das Warten aufgegeben wird;
- Erst starten, dann warten: Um mehrere unabhängige Operationen gleichzeitig auszuführen, starten Sie alle und warten dann auf sie ([allOf], [invokeAll], die Methode [close] des Executors);
- Auf eine gestartete Operation muss gewartet werden, oder sie muss überwacht werden: Eine vergessene Operation verbirgt ihre Ausnahmen ([exceptionally], [whenComplete] dienen zu ihrer Behandlung); indem man eine [CompletionException] oder eine [ExecutionException] zurückverfolgt, sucht man die eigentliche Ursache.
Die folgende Tabelle fasst die Entsprechungen zwischen der Welt der Plattform-Threads und blockierenden Wartevorgänge (vorheriges Kapitel), der von [CompletableFuture] und der der virtuellen Threads zusammen:
Plattform-Threads, blockierendes Warten | CompletableFuture | Virtuelle Threads |
[Thread.sleep(1000)] (blockiert den Thread) | [new CompletableFuture<Void>().completeOnTimeout(null, 1, SECONDS)] | [Thread.sleep(1000)] (gibt den Carrier frei) |
[thread.start()] gefolgt von [thread.join()] | [supplyAsync(...)] gefolgt von [join()] oder einer Fortsetzung | [executor.submit(...)] gefolgt von [get()] |
Auf mehrere Threads warten ([join] in einer Schleife) | [allOf(...)], [anyOf(...)] | [invokeAll(...)], [ExecutorCompletionService], [close()] |
Rückruf-Methoden ([CompletionHandler]) | [thenApply], [thenCompose], [thenCombine] | Der Code nach dem blockierenden Aufruf |
[try / catch] um [get()] ([ExecutionException]) | [exceptionally], [handle], [whenComplete] | [try / catch] (Standard) |
[thread.interrupt()] | [cancel(...)] (unterbricht nichts) | [future.cancel(true)] (unterbricht den Thread) |
[future.get(timeout, unit)] | [orTimeout(...)], [completeOnTimeout(...)] | [future.get(timeout, unit)] |
Thread-Pool fester Größe | Executor der Fortsetzung [xxxAsync] | [Semaphore] |
[BlockingQueue] (blockiert den Thread) | [Flow], [SubmissionPublisher] | [BlockingQueue] (gibt den Carrier frei) |
[ScheduledExecutorService] | [completeOnTimeout], [delayedExecutor] | [Thread.sleep] in einer Schleife |
Die folgenden Kapitel wenden diese Regeln an: Datenbankzugriff mit JDBC (Kapitel 10) und Hibernate (Kapitel 11), deren API-Operationen blockierend sind und sich natürlich mit virtuellen Threads vertragen, der TCP-Server, der jeden Client über einen virtuellen Thread bedient, und der [HttpClient]-Client (Kapitel 12); Spring-Boot-Webservices, bei denen der Tomcat-Server jede Anfrage über einen virtuellen Thread verarbeiten kann; und deren Clients (Kapitel 13).