Skip to content

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:

Image

  • 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.

// warum Asynchronität: 100 Operationen, die jeweils eine Sekunde warten
// (ein Warten simuliert eine E/A: Festplattenlesen, Netzwerkanfrage, SQL-Abfrage…)
import java.lang.management.ManagementFactory;

final int nbOperations = 100;
long start;

void main() throws InterruptedException {
    IO.println(nbOperations + " operations of one second, "
            + Runtime.getRuntime().availableProcessors() + " processors");

    // 1 - ein Plattform-Thread pro Operation, jeder Thread ist während des Wartens blockiert
    start = System.nanoTime();
    List<Thread> threads = new ArrayList<>();
    for (int i = 0; i < nbOperations; i++) {
        threads.add(Thread.ofPlatform().start(() -> waitFor(1000)));
    }
    display("1 - one platform thread per operation", jvmThreads());
    for (Thread thread : threads) {
        thread.join();
    }
    display("    end", -1);

    // 2 - die Operationen werden einem Pool aus 10 Threads übergeben, blockieren ihn aber
    start = System.nanoTime();
    try (ExecutorService pool = Executors.newFixedThreadPool(10)) {
        for (int i = 0; i < nbOperations; i++) {
            pool.submit(() -> waitFor(1000));
        }
        display("2 - pool of 10 threads, blocking waits", jvmThreads());
    } // close() wartet auf das Ende aller Operationen
    display("    end", -1);

    // 3 - ein virtueller Thread pro Operation: er gibt während des Wartens seinen Carrier-Thread frei
    start = System.nanoTime();
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        for (int i = 0; i < nbOperations; i++) {
            executor.submit(() -> waitFor(1000));
        }
        display("3 - one virtual thread per operation", jvmThreads());
    }
    display("    end", -1);

    // 4 - asynchrone Wartezeiten: kein Thread wartet, ein Timer schließt jede Operation ab
    start = System.nanoTime();
    var operations = new CompletableFuture<?>[nbOperations];
    for (int i = 0; i < nbOperations; i++) {
        operations[i] = new CompletableFuture<Void>().completeOnTimeout(null, 1000, TimeUnit.MILLISECONDS);
    }
    display("4 - asynchronous waits (CompletableFuture)", jvmThreads());
    CompletableFuture.allOf(operations).join();
    display("    end", -1);
}

// ein blockierendes Warten von [ms] Millisekunden
void waitFor(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// Anzahl der Plattform-Threads der JVM, eine halbe Sekunde nach dem Start der Operationen
int jvmThreads() {
    long elapsed = (System.nanoTime() - start) / 1_000_000;
    if (elapsed < 500) {
        waitFor(500 - elapsed);
    }
    return ManagementFactory.getThreadMXBean().getThreadCount();
}

// Anzeige der verstrichenen Zeit und, falls angegeben (>= 0), der Anzahl der Threads
void display(String message, int nbThreads) {
    String threadsInfo = nbThreads < 0 ? "" : String.format(", %3d threads in the JVM", nbThreads);
    long elapsed = (System.nanoTime() - start) / 1_000_000;
    IO.println(String.format("%-44s : %5d ms%s", message, elapsed, threadsInfo));
}

Ergebnisse:

> java Async01.java
100 operations of one second, 2 processors
1 - one platform thread per operation        :   534 ms, 106 threads in the JVM
    end                                      :  1061 ms
2 - pool of 10 threads, blocking waits       :   501 ms,  16 threads in the JVM
    end                                      : 10021 ms
3 - one virtual thread per operation         :   501 ms,  10 threads in the JVM
    end                                      :  1091 ms
4 - asynchronous waits (CompletableFuture)   :   500 ms,  11 threads in the JVM
    end                                      :  1003 ms

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).

// derselbe TCP-Client, geschrieben mit Callback-Methoden (NIO.2, Java 7) und dann mit einem virtuellen Thread (Java 21)
final int port = 27500;
final InetAddress local = InetAddress.getLoopbackAddress();
final ByteBuffer buffer = ByteBuffer.allocate(1024);
final CountDownLatch end = new CountDownLatch(1);

void main() throws IOException, InterruptedException {
    // ein minimaler Server, von einem Thread ausgeführt: er bedient zwei Clients und endet dann
    var listener = new ServerSocket(port, 10, local);
    Thread server = Thread.ofPlatform().name("server").start(() -> {
        try (listener) {
            for (int i = 1; i <= 2; i++) {
                try (Socket service = listener.accept()) {
                    // der Server lässt sich mit der Antwort Zeit
                    Thread.sleep(500);
                    byte[] message = ("Hello client no. " + i).getBytes(StandardCharsets.UTF_8);
                    service.getOutputStream().write(message);
                }
            }
        } catch (IOException | InterruptedException e) {
            display("server: " + e);
        }
    });
    display("start of the program");

    // 1 - der Stil "Callback-Methoden": AsynchronousSocketChannel und CompletionHandler
    var client = AsynchronousSocketChannel.open();
    // wir starten die Verbindung und geben das Objekt an, das nach ihrem Abschluss aufgerufen wird
    client.connect(new InetSocketAddress(local, port), client, new Connected());
    display("callbacks: connection started, the program continues");
    // der Haupt-Thread hat nichts mehr zu tun: er wartet auf das Signal der letzten Callback-Methode
    end.await();

    // 2 - der blockierende Stil, von einem virtuellen Thread ausgeführt: der Code liest sich von oben nach unten
    Thread virtual = Thread.ofVirtual().start(() -> {
        try (var client2 = new Socket(local, port)) {
            display("virtual thread: connected, read started");
            byte[] bytes = new byte[1024];
            int nbBytes = client2.getInputStream().read(bytes);
            String message = new String(bytes, 0, nbBytes, StandardCharsets.UTF_8);
            display("virtual thread: received [" + message + "]");
        } catch (IOException e) {
            display("virtual thread: " + e);
        }
    });
    virtual.join();
    server.join();
}

// Callback-Methode Nr. 1: die Verbindung steht (oder ist fehlgeschlagen)
class Connected implements CompletionHandler<Void, AsynchronousSocketChannel> {
    @Override
    public void completed(Void nothing, AsynchronousSocketChannel channel) {
        display("callbacks: connected, read started");
        // wir starten das Lesen der Serverantwort mit einem anderen Callback-Objekt
        channel.read(buffer, channel, new Received());
    }

    @Override
    public void failed(Throwable e, AsynchronousSocketChannel channel) {
        display("callbacks: connection failed: " + e);
        end.countDown();
    }
}

// Callback-Methode Nr. 2: Daten sind eingetroffen
class Received implements CompletionHandler<Integer, AsynchronousSocketChannel> {
    @Override
    public void completed(Integer nbBytes, AsynchronousSocketChannel channel) {
        display("callbacks: received [" + new String(buffer.array(), 0, nbBytes, StandardCharsets.UTF_8) + "]");
        try {
            channel.close();
        } catch (IOException e) {
            display("callbacks: " + e);
        }
        // wir benachrichtigen den Haupt-Thread
        end.countDown();
    }

    @Override
    public void failed(Throwable e, AsynchronousSocketChannel channel) {
        display("callbacks: read failed: " + e);
        end.countDown();
    }
}

// Ausgabe mit dem ausführenden Thread als Präfix
// (Name eines Plattform-Threads, Beschreibung eines virtuellen Threads)
void display(String message) {
    Thread thread = Thread.currentThread();
    IO.println("[" + (thread.isVirtual() ? thread.toString() : thread.getName()) + "] " + message);
}

Ergebnisse:

1
2
3
4
5
6
7
> java Async02.java
[main] start of the program
[main] callbacks: connection started, the program continues
[InnocuousThread-4] callbacks: connected, read started
[InnocuousThread-2] callbacks: received [Hello client no. 1]
[VirtualThread[#28]/runnable@ForkJoinPool-1-worker-1] virtual thread: connected, read started
[VirtualThread[#28]/runnable@ForkJoinPool-1-worker-2] virtual thread: received [Hello client no. 2]

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 ein TCP-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;
  • 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:

// CompletableFuture: Erzeugung, Warten, Zustand, Ergebnis, Fortsetzung
void main() throws InterruptedException {
    // 1 - supplyAsync übergibt eine Verarbeitung an einen Executor und liefert ein CompletableFuture<T>
    CompletableFuture<Long> f1 = CompletableFuture.supplyAsync(() -> {
        // eine Berechnung von einigen Zehntelsekunden
        long sum = 0;
        for (int i = 1; i <= 200_000_000; i++) {
            sum += i % 7;
        }
        return sum;
    });
    IO.println("f1 started, state: " + f1.state());
    // join() wartet auf das Ende der Verarbeitung, blockiert den aktuellen Thread und liefert ihr Ergebnis
    long result = f1.join();
    IO.println("f1 finished, state: " + f1.state() + ", result: " + result);

    // 2 - ein CompletableFuture, von einem Timer nach 300 ms abgeschlossen, ohne einen Thread zu belegen
    CompletableFuture<Void> f2 = new CompletableFuture<Void>()
            .completeOnTimeout(null, 300, TimeUnit.MILLISECONDS);
    IO.println("f2 started, state: " + f2.state());
    f2.join();
    IO.println("f2 finished, state: " + f2.state());

    // 3 - bereits abgeschlossene CompletableFutures, erfolgreich oder mit einem Fehler
    CompletableFuture<Integer> f3 = CompletableFuture.completedFuture(42);
    CompletableFuture<Integer> f4 = CompletableFuture.failedFuture(new IllegalStateException("failure"));
    IO.println("f3: state " + f3.state() + ", result " + f3.resultNow()
            + " ; f4: state " + f4.state() + ", exception " + f4.exceptionNow());

    // 4 - eine fehlschlagende Verarbeitung: join() wirft eine CompletionException, die ihre Exception einpackt
    CompletableFuture<Integer> f5 = CompletableFuture.supplyAsync(() -> Integer.parseInt("abc"));
    try {
        f5.join();
    } catch (CompletionException e) {
        IO.println("f5: state " + f5.state() + ", join() throws " + e.getClass().getSimpleName()
                + " containing " + e.getCause());
    }

    // 5 - get(), von der Schnittstelle Future geerbt, packt die Exception in eine ExecutionException ein
    try {
        f5.get();
    } catch (ExecutionException e) {
        IO.println("f5: get() throws " + e.getClass().getSimpleName()
                + " containing " + e.getCause().getClass().getSimpleName());
    }

    // 6 - eine Fortsetzung: was zu tun ist, wenn das CompletableFuture abgeschlossen ist
    CompletableFuture<Integer> f6 = f2.thenApply(nothing -> 2 * 21);
    CompletableFuture<Void> f7 = f6.thenAccept(value -> IO.println("f7: the continuation received " + value));
    f7.join();

    // 7 - isDone, isCompletedExceptionally, isCancelled
    IO.println("f1: isDone=" + f1.isDone() + ", f5: isDone=" + f5.isDone()
            + ", isCompletedExceptionally=" + f5.isCompletedExceptionally()
            + ", isCancelled=" + f5.isCancelled());
}

Ergebnisse:

> java Async03.java
f1 started, state: RUNNING
f1 finished, state: SUCCESS, result: 599999998
f2 started, state: RUNNING
f2 finished, state: SUCCESS
f3: state SUCCESS, result 42 ; f4: state FAILED, exception java.lang.IllegalStateException: failure
f5: state FAILED, join() throws CompletionException containing java.lang.NumberFormatException: For input string: "abc"
f5: get() throws ExecutionException containing NumberFormatException
f7: the continuation received 42
f1: isDone=true, f5: isDone=true, isCompletedExceptionally=true, isCancelled=false

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:

// Methoden, die ein CompletableFuture liefern: die Schritte werden mit thenRun und thenCompose zusammengesetzt
final long start = System.nanoTime();

void main() {
    display("call of makeCoffee");
    CompletableFuture<Void> preparation = makeCoffee();
    display("makeCoffee has returned: the program continues");
    display("call of countSugars");
    CompletableFuture<Integer> counting = countSugars(3);
    display("countSugars has returned");
    // wir kombinieren die beiden Operationen und warten dann auf das Ergebnis der Kombination
    int nbSugars = preparation.thenCombine(counting, (nothing, count) -> count).join();
    display("coffee ready, with " + nbSugars + " sugar(s)");
}

// eine Operation, die kein Ergebnis liefert: sie liefert ein CompletableFuture<Void>
CompletableFuture<Void> makeCoffee() {
    display("  coffee: the machine is heating up");
    // die Methode beschreibt die Abfolge der Schritte und kehrt dann sofort zurück
    return delay(1000)
            .thenRun(() -> display("  coffee: the machine is pouring the coffee"))
            .thenCompose(nothing -> delay(500))
            .thenRun(() -> display("  coffee: done"));
}

// eine Operation, die eine ganze Zahl liefert: sie liefert ein CompletableFuture<Integer>
CompletableFuture<Integer> countSugars(int count) {
    // eine Kette von Schritten, die mit einem bereits abgeschlossenen CompletableFuture beginnt
    CompletableFuture<Void> steps = CompletableFuture.completedFuture(null);
    for (int i = 1; i <= count; i++) {
        // ein Lambda kann nur eine effektiv finale lokale Variable verwenden
        int number = i;
        steps = steps.thenCompose(nothing -> delay(200))
                .thenRun(() -> display("  sugar no. " + number));
    }
    // am Ende der Kette das Ergebnis: die Anzahl der Zuckerstücke
    return steps.thenApply(nothing -> count);
}

// das asynchrone Äquivalent von Thread.sleep: ein nach [ms] Millisekunden abgeschlossenes CompletableFuture
CompletableFuture<Void> delay(long ms) {
    return new CompletableFuture<Void>().completeOnTimeout(null, ms, TimeUnit.MILLISECONDS);
}

// Ausgabe mit der seit dem Start verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

> java Async04.java
    3 ms : call of makeCoffee
   12 ms :   coffee: the machine is heating up
   15 ms : makeCoffee has returned: the program continues
   16 ms : call of countSugars
   17 ms : countSugars has returned
  217 ms :   sugar no. 1
  417 ms :   sugar no. 2
  618 ms :   sugar no. 3
 1014 ms :   coffee: the machine is pouring the coffee
 1515 ms :   coffee: done
 1516 ms : coffee ready, with 3 sugar(s)

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:

// derselbe Kaffee mit virtuellen Threads: gewöhnliche, blockierende Methoden, die sich von oben nach unten lesen
final long start = System.nanoTime();

void main() throws InterruptedException, ExecutionException {
    // ein Executor, der für jede ihm übergebene Aufgabe einen virtuellen Thread erzeugt
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        display("start of makeCoffee");
        Future<?> preparation = executor.submit(this::makeCoffee);
        display("makeCoffee is started: the program continues");
        display("start of countSugars");
        Future<Integer> counting = executor.submit(() -> countSugars(3));
        display("countSugars is started");
        // jetzt warten wir auf die beiden Ergebnisse
        preparation.get();
        int nbSugars = counting.get();
        display("coffee ready, with " + nbSugars + " sugar(s)");
    }
}

// eine gewöhnliche Methode, die kein Ergebnis liefert
void makeCoffee() {
    display("  coffee: the machine is heating up");
    // ein blockierendes Warten: auf einem virtuellen Thread gibt es den Carrier-Thread frei
    sleep(1000);
    display("  coffee: the machine is pouring the coffee");
    sleep(500);
    display("  coffee: done");
}

// eine gewöhnliche Methode, die eine ganze Zahl liefert
int countSugars(int count) {
    for (int i = 1; i <= count; i++) {
        sleep(200);
        display("  sugar no. " + i);
    }
    return count;
}

// Thread.sleep ohne geprüfte Exception: eine Unterbrechung wird zu einer CancellationException
void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        // wir setzen das Unterbrechungs-Flag des Threads wieder, bevor wir die Exception werfen
        Thread.currentThread().interrupt();
        throw new CancellationException("wait interrupted");
    }
}

// Ausgabe mit der seit dem Start verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

> java Async05.java
    3 ms : start of makeCoffee
   17 ms :   coffee: the machine is heating up
   18 ms : makeCoffee is started: the program continues
   18 ms : start of countSugars
   19 ms : countSugars is started
  221 ms :   sugar no. 1
  422 ms :   sugar no. 2
  623 ms :   sugar no. 3
 1020 ms :   coffee: the machine is pouring the coffee
 1521 ms :   coffee: done
 1522 ms : coffee ready, with 3 sugar(s)

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:

// welcher Thread führt den Rest einer Verarbeitung aus?
void main() throws InterruptedException {
    display("start of the program, parallelism of the common pool: " + ForkJoinPool.getCommonPoolParallelism());

    // 1 - die Fortsetzung eines bereits abgeschlossenen CompletableFuture wird sofort vom Aufrufer ausgeführt
    CompletableFuture.completedFuture(42).thenAccept(value -> display("1 - thenAccept, result known"));

    // 2 - andernfalls wird sie von dem Thread ausgeführt, der das CompletableFuture abschließt
    delay(100).thenRun(() -> display("2 - thenRun after a delay")).join();
    CompletableFuture<String> order = new CompletableFuture<>();
    order.thenAccept(text -> display("2 - thenAccept after complete(\"" + text + "\")"));
    Thread.ofPlatform().name("deliverer").start(() -> order.complete("delivered")).join();

    // 3 - die xxxAsync-Varianten übergeben die Fortsetzung an einen Executor
    delay(100).thenRunAsync(() -> display("3 - thenRunAsync, default executor")).join();
    ThreadFactory factory = Thread.ofPlatform().name("pool-", 1).factory();
    try (ExecutorService pool = Executors.newFixedThreadPool(2, factory)) {
        delay(100).thenRunAsync(() -> display("3 - thenRunAsync, chosen executor"), pool).join();
        CompletableFuture.runAsync(() -> display("3 - runAsync, chosen executor"), pool).join();
    }
    try (ExecutorService virtuals = Executors.newVirtualThreadPerTaskExecutor()) {
        CompletableFuture.runAsync(() -> display("3 - runAsync, virtual threads"), virtuals).join();
    }

    // 4 - ein virtueller Thread kann nach jedem Warten den Carrier-Thread wechseln
    Thread a = Thread.ofVirtual().start(() -> work("A"));
    Thread b = Thread.ofVirtual().start(() -> work("B"));
    a.join();
    b.join();
    display("end of the program");
}

void work(String name) {
    for (int i = 1; i <= 3; i++) {
        display("  " + name + i + " : before the wait");
        sleep(100);
    }
}

// ein nach [ms] Millisekunden abgeschlossenes CompletableFuture
CompletableFuture<Void> delay(long ms) {
    return new CompletableFuture<Void>().completeOnTimeout(null, ms, TimeUnit.MILLISECONDS);
}

// Thread.sleep ohne geprüfte Exception: eine Unterbrechung wird zu einer CancellationException
void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new CancellationException("wait interrupted");
    }
}

// Ausgabe mit dem ausführenden Thread als Präfix
// (Name eines Plattform-Threads, Beschreibung eines virtuellen Threads)
void display(String message) {
    Thread thread = Thread.currentThread();
    IO.println("[" + (thread.isVirtual() ? thread.toString() : thread.getName()) + "] " + message);
}

Ergebnisse:

> java Async06.java
[main] start of the program, parallelism of the common pool: 1
[main] 1 - thenAccept, result known
[ForkJoinPool.commonPool-delayScheduler] 2 - thenRun after a delay
[deliverer] 2 - thenAccept after complete("delivered")
[ForkJoinPool.commonPool-worker-1] 3 - thenRunAsync, default executor
[pool-1] 3 - thenRunAsync, chosen executor
[pool-2] 3 - runAsync, chosen executor
[VirtualThread[#28]/runnable@ForkJoinPool-1-worker-1] 3 - runAsync, virtual threads
[VirtualThread[#31]/runnable@ForkJoinPool-1-worker-1]   A1 : before the wait
[VirtualThread[#32]/runnable@ForkJoinPool-1-worker-2]   B1 : before the wait
[VirtualThread[#32]/runnable@ForkJoinPool-1-worker-2]   B2 : before the wait
[VirtualThread[#31]/runnable@ForkJoinPool-1-worker-1]   A2 : before the wait
[VirtualThread[#31]/runnable@ForkJoinPool-1-worker-2]   A3 : before the wait
[VirtualThread[#32]/runnable@ForkJoinPool-1-worker-1]   B3 : before the wait
[main] end of the program

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:

// das Hauptprogramm wartet auf das Ende der asynchronen Operationen und setzt den Exit-Code
void main(String[] args) {
    // die Anzahl der Sekunden wird als Argument übergeben
    if (args.length != 1 || !args[0].matches("\\d+")) {
        IO.println("syntax: java Async07.java nbSeconds");
        // der Exit-Code des Programms: 0 bei Erfolg, sonst ein Fehler
        System.exit(1);
    }
    CompletableFuture<Void> countdown = countDown(Integer.parseInt(args[0]));
    IO.println("countdown started");
    // ohne dieses Warten würde main sofort enden und mit ihm das Programm
    countdown.join();
    IO.println("finished");
}

// eine asynchrone Schleife wird mit Rekursion geschrieben: jeder Schritt startet den nächsten
CompletableFuture<Void> countDown(int nbSeconds) {
    if (nbSeconds == 0) {
        return CompletableFuture.completedFuture(null);
    }
    IO.println("still " + nbSeconds + " s");
    return delay(1000).thenCompose(nothing -> countDown(nbSeconds - 1));
}

// ein nach [ms] Millisekunden abgeschlossenes CompletableFuture
CompletableFuture<Void> delay(long ms) {
    return new CompletableFuture<Void>().completeOnTimeout(null, ms, TimeUnit.MILLISECONDS);
}

Ergebnisse, zuerst mit und dann ohne Argument:

1
2
3
4
5
6
> java Async07.java 3
still 3 s
countdown started
still 2 s
still 1 s
finished
1
2
3
4
> java Async07.java
syntax: java Async07.java nbSeconds
> echo $?
1

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:

// sequenzielle und nebenläufige Ausführung von Ein-Sekunden-Operationen
long start = System.nanoTime();

void main() throws InterruptedException {
    // 1 - nacheinander: auf jede Operation wird gewartet, bevor die nächste startet
    int a = readTemperature("Angers").join();
    int b = readTemperature("Brest").join();
    int c = readTemperature("Colmar").join();
    IO.println("in sequence: " + a + ", " + b + ", " + c + " in " + elapsed() + " ms");

    // 2 - nebenläufig: wir starten die drei Operationen und warten dann auf sie
    start = System.nanoTime();
    CompletableFuture<Integer> fa = readTemperature("Angers");
    CompletableFuture<Integer> fb = readTemperature("Brest");
    CompletableFuture<Integer> fc = readTemperature("Colmar");
    CompletableFuture.allOf(fa, fb, fc).join();
    IO.println("concurrently: " + fa.resultNow() + ", " + fb.resultNow() + ", " + fc.resultNow()
            + " in " + elapsed() + " ms");

    // 3 - allOf auf einer Liste von CompletableFutures, dann die Liste der Ergebnisse
    start = System.nanoTime();
    List<String> cities = List.of("Angers", "Brest", "Colmar", "Dijon", "Évry", "Foix");
    List<CompletableFuture<Integer>> readings = cities.stream().map(this::readTemperature).toList();
    List<Integer> temperatures = CompletableFuture.allOf(readings.toArray(CompletableFuture[]::new))
            .thenApply(nothing -> readings.stream().map(CompletableFuture::join).toList())
            .join();
    IO.println(cities.size() + " cities: " + temperatures + " in " + elapsed() + " ms");

    // 4 - dasselbe mit virtuellen Threads und einer blockierenden Methode
    start = System.nanoTime();
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        List<Callable<Integer>> tasks = cities.stream()
                .map(city -> (Callable<Integer>) () -> readTemperatureBlocking(city))
                .toList();
        // invokeAll startet alle Aufgaben und liefert ihre Futures, wenn alle beendet sind
        List<Integer> results = executor.invokeAll(tasks).stream().map(Future::resultNow).toList();
        IO.println(cities.size() + " cities (virtual threads): " + results + " in " + elapsed() + " ms");
    }
}

// simuliert die Abfrage eines entfernten Dienstes, der in einer Sekunde antwortet
CompletableFuture<Integer> readTemperature(String city) {
    // eine vom Namen der Stadt abgeleitete "Temperatur"
    return delay(1000).thenApply(nothing -> 10 + city.length());
}

// dieselbe Operation, blockierend geschrieben
int readTemperatureBlocking(String city) throws InterruptedException {
    Thread.sleep(1000);
    return 10 + city.length();
}

// ein nach [ms] Millisekunden abgeschlossenes CompletableFuture
CompletableFuture<Void> delay(long ms) {
    return new CompletableFuture<Void>().completeOnTimeout(null, ms, TimeUnit.MILLISECONDS);
}

// seit [start] verstrichene Millisekunden
long elapsed() {
    return (System.nanoTime() - start) / 1_000_000;
}

Ergebnisse:

1
2
3
4
5
> java Async08.java
in sequence: 16, 15, 16 in 3007 ms
concurrently: 16, 15, 16 in 1000 ms
6 cities: [16, 15, 16, 15, 14, 14] in 1006 ms
6 cities (virtual threads): [16, 15, 16, 15, 14, 14] in 1013 ms

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:

// anyOf: auf die erste abgeschlossene Operation reagieren
long start = System.nanoTime();

void main() {
    // 1 - wir fragen drei Spiegelserver ab und behalten die erste Antwort
    List<CompletableFuture<String>> requests = List.of(
            query("mirror-paris", 800),
            query("mirror-lyon", 300),
            query("mirror-lille", 600));
    // anyOf liefert ein CompletableFuture<Object>, das wie die erste abgeschlossene Operation abgeschlossen wird
    Object first = CompletableFuture.anyOf(requests.toArray(CompletableFuture[]::new)).join();
    display("first answer: " + first);
    // die anderen Anfragen laufen weiter: wir warten hier auf sie, um ihre Antworten zu sehen
    CompletableFuture.allOf(requests.toArray(CompletableFuture[]::new)).join();
    display("all the answers: " + requests.stream().map(CompletableFuture::resultNow).toList());

    // 2 - eine zeitlich begrenzte Operation: wir lassen sie gegen eine Verzögerung "antreten"
    start = System.nanoTime();
    CompletableFuture<String> slow = query("slow-server", 2000);
    CompletableFuture<Object> race = CompletableFuture.anyOf(slow, delay(500));
    race.join();
    if (slow.isDone()) {
        display("answer obtained in time: " + slow.join());
    } else {
        display("the slow server did not answer within the 500 ms delay");
    }
}

// simuliert einen Server, der nach [duration] Millisekunden antwortet
CompletableFuture<String> query(String server, int duration) {
    return delay(duration).thenApply(nothing -> server + " (" + duration + " ms)");
}

// ein nach [ms] Millisekunden abgeschlossenes CompletableFuture
CompletableFuture<Void> delay(long ms) {
    return new CompletableFuture<Void>().completeOnTimeout(null, ms, TimeUnit.MILLISECONDS);
}

// Ausgabe mit der seit [start] verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

1
2
3
4
> java Async09.java
  309 ms : first answer: mirror-lyon (300 ms)
  806 ms : all the answers: [mirror-paris (800 ms), mirror-lyon (300 ms), mirror-lille (600 ms)]
  500 ms : the slow server did not answer within the 500 ms delay

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:

// die Ergebnisse in der Reihenfolge verarbeiten, in der die Operationen enden
long start = System.nanoTime();
final int[] durations = {900, 300, 700, 100, 500};

void main() throws InterruptedException, ExecutionException {
    // 1 - mit CompletableFutures: eine Fortsetzung pro Operation, ausgeführt, sobald sie endet
    List<CompletableFuture<Void>> displays = new ArrayList<>();
    for (int i = 0; i < durations.length; i++) {
        displays.add(process("file" + i + ".txt", durations[i]).thenAccept(this::display));
    }
    CompletableFuture.allOf(displays.toArray(CompletableFuture[]::new)).join();
    display("1 - all the files have been processed");

    // 2 - mit virtuellen Threads: ein CompletionService liefert die Futures in der Reihenfolge ihres Endes
    start = System.nanoTime();
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        CompletionService<String> service = new ExecutorCompletionService<>(executor);
        for (int i = 0; i < durations.length; i++) {
            String file = "file" + i + ".txt";
            int duration = durations[i];
            service.submit(() -> processBlocking(file, duration));
        }
        // take() wartet (blockierend) auf die nächste beendete Aufgabe
        for (int i = 0; i < durations.length; i++) {
            display(service.take().get());
        }
    }
    display("2 - all the files have been processed");
}

// simuliert die Verarbeitung einer Datei, die [duration] Millisekunden dauert
CompletableFuture<String> process(String file, int duration) {
    return new CompletableFuture<String>()
            .completeOnTimeout(file + " processed in " + duration + " ms", duration, TimeUnit.MILLISECONDS);
}

// dieselbe Verarbeitung, blockierend geschrieben
String processBlocking(String file, int duration) throws InterruptedException {
    Thread.sleep(duration);
    return file + " processed in " + duration + " ms";
}

// Ausgabe mit der seit [start] verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

> java Async10.java
  107 ms : file3.txt processed in 100 ms
  318 ms : file1.txt processed in 300 ms
  508 ms : file4.txt processed in 500 ms
  707 ms : file2.txt processed in 700 ms
  906 ms : file0.txt processed in 900 ms
  907 ms : 1 - all the files have been processed
  115 ms : file3.txt processed in 100 ms
  314 ms : file1.txt processed in 300 ms
  514 ms : file4.txt processed in 500 ms
  714 ms : file2.txt processed in 700 ms
  914 ms : file0.txt processed in 900 ms
  915 ms : 2 - all the files have been processed

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:

// Exceptions in asynchronem Code
void main() {
    // 1 - join() wirft eine CompletionException, die die Exception der Operation einpackt
    try {
        int value = readValue("twelve").join();
        IO.println("value = " + value);
    } catch (CompletionException e) {
        IO.println("1 - join() throws " + name(e) + ", with cause " + name(e.getCause())
                + " : " + e.getCause().getMessage());
    }

    // 2 - exceptionally liefert im Fehlerfall einen Ersatzwert
    int value = readValue("thirteen").exceptionally(e -> -1).join();
    IO.println("2 - exceptionally: replacement value " + value);

    // 3 - handle erhält das Ergebnis oder die Exception; whenComplete beobachtet sie, ohne etwas zu ändern
    for (String text : List.of("14", "fifteen")) {
        String outcome = readValue(text)
                .whenComplete((v, e) -> IO.println("3 - whenComplete saw: " + (e == null ? v : name(e))))
                .handle((v, e) -> e == null ? "value " + v : "failure, " + name(cause(e)))
                .join();
        IO.println("3 - handle returned: " + outcome);
    }

    // 4 - eine Methode, die ein CompletableFuture liefert, kann auch sofort beim Aufruf eine Exception werfen
    try {
        readValue(" ");
        IO.println("4 - the call threw nothing");
    } catch (IllegalArgumentException e) {
        IO.println("4 - it is the call itself that throws " + name(e) + " : " + e.getMessage());
    }

    // 5 - allOf mit mehreren fehlschlagenden Operationen
    List<CompletableFuture<Integer>> readings = Stream.of("1", "two", "3", "four")
            .map(this::readValue)
            .toList();
    try {
        CompletableFuture.allOf(readings.toArray(CompletableFuture[]::new)).join();
    } catch (CompletionException e) {
        // join() wirft nur eine der Exceptions erneut…
        IO.println("5 - allOf fails with " + name(e.getCause()) + " : " + e.getCause().getMessage());
        // … aber jede Operation hat ihre Exception oder ihr Ergebnis behalten
        for (CompletableFuture<Integer> reading : readings) {
            switch (reading.state()) {
                case SUCCESS -> IO.println("      success, result = " + reading.resultNow());
                case FAILED -> IO.println("      failure, " + name(reading.exceptionNow())
                        + " : " + reading.exceptionNow().getMessage());
                default -> IO.println("      unexpected state: " + reading.state());
            }
        }
    }
}

// eine asynchrone Operation, die fehlschlägt, wenn die Zeichenkette keine ganze Zahl ist
CompletableFuture<Integer> readValue(String text) {
    // sofortige Prüfung des Parameters, bevor die Operation gestartet wird
    if (text == null || text.isBlank()) {
        throw new IllegalArgumentException("the text must not be empty");
    }
    // das Lesen dauert einen Moment
    return new CompletableFuture<Void>()
            .completeOnTimeout(null, 100, TimeUnit.MILLISECONDS)
            .thenApply(nothing -> Integer.parseInt(text));
}

// Fortsetzungen erhalten oft eine CompletionException: wir gehen auf ihre Ursache zurück
Throwable cause(Throwable e) {
    return e instanceof CompletionException && e.getCause() != null ? e.getCause() : e;
}

// der einfache Name der Klasse einer Exception
String name(Throwable e) {
    return e.getClass().getSimpleName();
}

Ergebnisse:

> java Async11.java
1 - join() throws CompletionException, with cause NumberFormatException : For input string: "twelve"
2 - exceptionally: replacement value -1
3 - whenComplete saw: 14
3 - handle returned: value 14
3 - whenComplete saw: CompletionException
3 - handle returned: failure, NumberFormatException
4 - it is the call itself that throws IllegalArgumentException : the text must not be empty
5 - allOf fails with NumberFormatException : For input string: "two"
      success, result = 1
      failure, NumberFormatException : For input string: "two"
      success, result = 3
      failure, NumberFormatException : For input string: "four"

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:

// eine gestartete und dann vergessene Operation: ihre Exception geht verloren
void main() {
    // der Handler für die Exceptions, die in einem Thread von keinem Code abgefangen wurden
    Thread.setDefaultUncaughtExceptionHandler((thread, e) ->
            IO.println("uncaught exception in [" + thread.getName() + "] : " + e.getMessage()));

    // 1 - ein abgewartetes CompletableFuture: seine Exception wird abgefangen
    try {
        save("a").join();
    } catch (CompletionException e) {
        IO.println("1 - awaited CompletableFuture: exception caught: " + e.getCause().getMessage());
    }

    // 2 - ein vergessenes CompletableFuture: seine Exception bleibt im Objekt, niemand wird sie sehen
    save("b");
    IO.println("2 - forgotten CompletableFuture: the call has returned");

    // 3 - eine an einen Executor übergebene und vergessene Aufgabe: ihre Exception bleibt im Future
    ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
    executor.submit(() -> saveBlocking("c"));
    IO.println("3 - forgotten Future: the task is started");

    // 4 - ein Thread: die nicht abgefangene Exception beendet den Thread und erreicht den Handler
    Thread.ofVirtual().name("recorder").start(() -> saveBlocking("d"));
    IO.println("4 - virtual thread started");

    // 5 - Start ohne Warten, aber mit Behandlung des Fehlers
    save("e").exceptionally(e -> {
        IO.println("5 - failure reported by exceptionally: " + e.getCause().getMessage());
        return null;
    });

    // das Programm setzt seine Arbeit fort…
    for (int i = 1; i <= 4; i++) {
        sleep(100);
        IO.println("the program is working (" + i + ")");
    }
    executor.close();
    IO.println("normal end of the program");
}

// eine asynchrone Operation, die nach 200 ms fehlschlägt
CompletableFuture<Void> save(String data) {
    return new CompletableFuture<Void>()
            .completeOnTimeout(null, 200, TimeUnit.MILLISECONDS)
            .thenRun(() -> {
                throw new IllegalStateException("failed to save [" + data + "]");
            });
}

// dieselbe Operation, blockierend geschrieben
void saveBlocking(String data) {
    sleep(200);
    throw new IllegalStateException("failed to save [" + data + "]");
}

// Thread.sleep ohne geprüfte Exception: eine Unterbrechung wird zu einer CancellationException
void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new CancellationException("wait interrupted");
    }
}

Ergebnisse:

> java Async12.java
1 - awaited CompletableFuture: exception caught: failed to save [a]
2 - forgotten CompletableFuture: the call has returned
3 - forgotten Future: the task is started
4 - virtual thread started
the program is working (1)
5 - failure reported by exceptionally: failed to save [e]
uncaught exception in [recorder] : failed to save [d]
the program is working (2)
the program is working (3)
the program is working (4)
normal end of the program

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:

// eine Operation abbrechen: Future.cancel(true) und Thread-Unterbrechung
long start = System.nanoTime();

void main() throws InterruptedException, ExecutionException {
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        // 1 - wir warten höchstens 1,2 Sekunden auf das Ergebnis und brechen die Operation dann ab
        Future<?> download1 = executor.submit(() -> download(10));
        try {
            download1.get(1200, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            // cancel(true) unterbricht den Thread, der die Aufgabe ausführt
            download1.cancel(true);
            display("1 - " + e.getClass().getSimpleName() + ", state: " + download1.state());
        }

        // 2 - eine Berechnung, die regelmäßig selbst prüft, ob sie unterbrochen wurde
        start = System.nanoTime();
        Future<Long> computation = executor.submit(this::compute);
        Thread.sleep(300);
        computation.cancel(true);
        try {
            display("2 - result: " + computation.get());
        } catch (CancellationException e) {
            display("2 - get() throws " + e.getClass().getSimpleName() + ", state: " + computation.state());
        }
        Thread.sleep(100);

        // 3 - der Abbruch wird vom Programm nach 700 ms angefordert
        start = System.nanoTime();
        Future<?> download3 = executor.submit(() -> download(10));
        Thread.sleep(700);
        display("3 - the program requests the cancellation");
        download3.cancel(true);
        display("3 - isCancelled=" + download3.isCancelled());
        Thread.sleep(100);

        // 4 - cancel() auf einem CompletableFuture unterbricht die dargestellte Operation nicht
        start = System.nanoTime();
        CompletableFuture<Void> download4 = CompletableFuture.runAsync(() -> download(3), executor);
        Thread.sleep(400);
        download4.cancel(true);
        display("4 - CompletableFuture cancelled: isCancelled=" + download4.isCancelled()
                + ", but the operation continues");
    } // close() wartet auf das Ende aller Aufgaben
}

// simuliert den Download von [nbBlocks] Datenblöcken (ein Block alle 300 ms)
void download(int nbBlocks) {
    try {
        for (int i = 1; i <= nbBlocks; i++) {
            // ein blockierendes Warten wird unterbrochen, sobald der Thread unterbrochen wird
            Thread.sleep(300);
            display("  block " + i + "/" + nbBlocks + " received");
        }
    } catch (InterruptedException e) {
        display("  download interrupted");
    }
}

// eine lange Berechnung, die das Unterbrechungs-Flag ihres Threads alle 1.000.000 Durchläufe prüft
long compute() {
    long sum = 0;
    for (long i = 0; i < 100_000_000_000L; i++) {
        if (i % 1_000_000 == 0 && Thread.currentThread().isInterrupted()) {
            display("  computation interrupted at round " + i);
            return -1;
        }
        sum += i % 7;
    }
    return sum;
}

// Ausgabe mit der seit [start] verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

> java Async13.java
  318 ms :   block 1/10 received
  638 ms :   block 2/10 received
  939 ms :   block 3/10 received
 1212 ms :   download interrupted
 1214 ms : 1 - TimeoutException, state: CANCELLED
  301 ms : 2 - get() throws CancellationException, state: CANCELLED
  303 ms :   computation interrupted at round 131000000
  302 ms :   block 1/10 received
  603 ms :   block 2/10 received
  701 ms : 3 - the program requests the cancellation
  702 ms :   download interrupted
  702 ms : 3 - isCancelled=true
  309 ms :   block 1/3 received
  404 ms : 4 - CompletableFuture cancelled: isCancelled=true, but the operation continues
  609 ms :   block 2/3 received
  910 ms :   block 3/3 received

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:

// fünf Verarbeitungen von 1 bis 5 Sekunden, von virtuellen Threads ausgeführt:
// Nr. 3 wirft eine Exception, Nr. 4 wird abgebrochen
long start;

void main() throws InterruptedException {
    start = System.nanoTime();
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
         ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor()) {
        // der CompletionService liefert jede Aufgabe, sobald sie beendet ist
        CompletionService<ProcessingResult> service = new ExecutorCompletionService<>(executor);
        List<Future<ProcessingResult>> tasks = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            int number = i;
            tasks.add(service.submit(() -> sleep(number, number + 1)));
        }
        // wir brechen die Verarbeitung Nr. 4 nach 2,5 Sekunden ab
        scheduler.schedule(() -> tasks.get(4).cancel(true), 2500, TimeUnit.MILLISECONDS);
        display("the " + tasks.size() + " processings are started");

        // wir verwenden jede Verarbeitung, sobald sie beendet ist, egal wie sie geendet hat
        for (int i = 0; i < tasks.size(); i++) {
            Future<ProcessingResult> task = service.take();
            int number = tasks.indexOf(task);
            String outcome = switch (task.state()) {
                case SUCCESS -> String.format("finished: scheduled duration %d s, actual duration %.1f s",
                        task.resultNow().duration(), task.resultNow().actualDuration());
                case FAILED -> "encountered the following error: " + task.exceptionNow().getMessage();
                case CANCELLED -> "cancelled";
                case RUNNING -> "still running?";
            };
            display("processing " + number + " " + outcome);
        }
    }
}

// die Verarbeitung: [duration] Sekunden schlafen, in Ein-Sekunden-Scheiben
ProcessingResult sleep(int number, int duration) throws InterruptedException {
    long processingStart = System.nanoTime();
    // Exception für die Verarbeitung Nr. 3
    if (number == 3) {
        throw new IllegalStateException("test....");
    }
    for (int i = 1; i <= duration; i++) {
        Thread.sleep(1000);
    }
    // das an den Aufrufer zurückgegebene Ergebnis
    return new ProcessingResult(duration, (System.nanoTime() - processingStart) / 1e9);
}

// das Ergebnis einer Verarbeitung
record ProcessingResult(int duration, double actualDuration) {
}

// Ausgabe mit der seit dem Start verstrichenen Zeit, in Sekunden
void display(String message) {
    IO.println(String.format("%4.1f s : %s", (System.nanoTime() - start) / 1e9, message));
}

Ergebnisse:

1
2
3
4
5
6
7
> java Async14.java
 0.0 s : the 5 processings are started
 0.0 s : processing 3 encountered the following error: test....
 1.0 s : processing 0 finished: scheduled duration 1 s, actual duration 1.0 s
 2.0 s : processing 1 finished: scheduled duration 2 s, actual duration 2.0 s
 2.5 s : processing 4 cancelled
 3.0 s : processing 2 finished: scheduled duration 3 s, actual duration 3.0 s

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.

// die Dauer eines Wartens begrenzen: orTimeout, completeOnTimeout, get(timeout)
long start = System.nanoTime();

void main() throws InterruptedException, ExecutionException {
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        // 1 - orTimeout: wir warten nicht länger als eine Sekunde
        CompletableFuture<String> slow = CompletableFuture.supplyAsync(
                () -> queryBlocking("slow-server", 3000), executor);
        try {
            display("1 - answer: " + slow.orTimeout(1, TimeUnit.SECONDS).join());
        } catch (CompletionException e) {
            display("1 - " + e.getCause().getClass().getSimpleName() + ", state: " + slow.state());
        }
        // die Operation selbst läuft weiter: wir lassen sie zu Ende laufen
        Thread.sleep(2200);

        // 2 - completeOnTimeout: nach einer Sekunde begnügen wir uns mit einer Standardantwort
        start = System.nanoTime();
        String answer = query("slow-server", 3000)
                .completeOnTimeout("default answer", 1, TimeUnit.SECONDS)
                .join();
        display("2 - " + answer);

        // 3 - um die Operation wirklich zu stoppen, unterbrechen wir den Thread, der sie ausführt
        start = System.nanoTime();
        Future<String> slow3 = executor.submit(() -> queryBlocking("slow-server", 3000));
        try {
            display("3 - answer: " + slow3.get(1, TimeUnit.SECONDS));
        } catch (TimeoutException e) {
            slow3.cancel(true);
            display("3 - one-second timeout exceeded, operation cancelled, state: " + slow3.state());
        }
    }

    // 4 - zwei Stoppursachen: das für jede Verarbeitung eigene Timeout und ein allgemeiner Stopp
    start = System.nanoTime();
    CompletableFuture<Void> generalStop = new CompletableFuture<>();
    CompletableFuture<Void> all = CompletableFuture.allOf(
            processWithTimeout("fast", 500, 1000, generalStop),
            processWithTimeout("slow", 3000, 1000, generalStop),
            processWithTimeout("medium", 1500, 2000, generalStop));
    // der Aufrufer fordert den allgemeinen Stopp nach 1.200 ms an
    Thread.sleep(1200);
    display("4 - general stop requested");
    generalStop.complete(null);
    all.join();
}

// eine auf [timeout] Millisekunden begrenzte Verarbeitung, die auch vom Aufrufer gestoppt werden kann
CompletableFuture<Void> processWithTimeout(String name, int duration, int timeout, CompletableFuture<Void> stop) {
    CompletableFuture<String> answer = query(name, duration).orTimeout(timeout, TimeUnit.MILLISECONDS);
    // der allgemeine Stopp bricht das Warten auf die Antwort ab
    stop.thenRun(() -> answer.cancel(false));
    // wir untersuchen, wie das Warten geendet hat
    return answer.handle((text, e) -> switch (e) {
        case null -> text;
        case TimeoutException _ -> name + " : timeout of " + timeout + " ms exceeded";
        case CancellationException _ -> name + " : stopped at the caller's request";
        default -> name + " : " + e;
    }).thenAccept(message -> display("4 - " + message));
}

// simuliert einen Server, der nach [duration] Millisekunden antwortet
CompletableFuture<String> query(String server, int duration) {
    return new CompletableFuture<String>()
            .completeOnTimeout(server + " answered in " + duration + " ms", duration, TimeUnit.MILLISECONDS);
}

// dieselbe Operation, blockierend geschrieben
String queryBlocking(String server, int duration) {
    try {
        Thread.sleep(duration);
        display("  " + server + " has finished its work");
        return server + " answered in " + duration + " ms";
    } catch (InterruptedException e) {
        display("  " + server + " was interrupted");
        throw new CancellationException("operation interrupted");
    }
}

// Ausgabe mit der seit [start] verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

> java Async15.java
 1028 ms : 1 - TimeoutException, state: FAILED
 3025 ms :   slow-server has finished its work
 1001 ms : 2 - default answer
 1003 ms :   slow-server was interrupted
 1004 ms : 3 - one-second timeout exceeded, operation cancelled, state: CANCELLED
  501 ms : 4 - fast answered in 500 ms
 1005 ms : 4 - slow : timeout of 1000 ms exceeded
 1206 ms : 4 - general stop requested
 1207 ms : 4 - medium : stopped at the caller's request

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:

// den Fortschritt einer Operation mit einem Consumer melden; der Benutzer kann sie abbrechen
void main() throws InterruptedException {
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        IO.println("Copy in progress, press [Enter] to cancel it");
        // das Kopieren wird von einem virtuellen Thread ausgeführt; die Methode display zeigt seine Meldungen an
        Future<Integer> copy = executor.submit(() -> copy(8, this::display));
        // ein anderer virtueller Thread wartet darauf, dass der Benutzer [Enter] drückt, um das Kopieren abzubrechen
        Thread.ofVirtual().start(() -> {
            // readln liefert null, wenn die Standardeingabe geschlossen ist: wir brechen nichts ab
            if (IO.readln() != null) {
                copy.cancel(true);
            }
        });
        try {
            IO.println("Copy finished: " + copy.get() + " files copied");
        } catch (CancellationException e) {
            IO.println("Copy cancelled by the user");
        } catch (ExecutionException e) {
            IO.println("Copy failed: " + e.getCause());
        }
    }
}

// die Operation weiß nicht, wie ihr Fortschritt angezeigt wird: sie meldet ihn nur
int copy(int nbFiles, Consumer<Progress> progress) throws InterruptedException {
    for (int i = 1; i <= nbFiles; i++) {
        // das Kopieren einer Datei
        Thread.sleep(300);
        // die Fortschrittsmeldung (der Aufrufer möchte sie eventuell nicht: progress ist dann null)
        if (progress != null) {
            progress.accept(new Progress(100 * i / nbFiles, "file" + i + ".dat"));
        }
    }
    return nbFiles;
}

// eine Fortschrittsmeldung
record Progress(int percentage, String file) {
}

// Anzeige der Fortschrittsmeldungen in der Konsole: ein Balken aus 20 Zeichen
void display(Progress progress) {
    int nbHashes = progress.percentage() / 5;
    String bar = "#".repeat(nbHashes) + ".".repeat(20 - nbHashes);
    IO.println(String.format("[%s] %3d %% %s", bar, progress.percentage(), progress.file()));
}

Ergebnisse ohne Abbruch:

> java Async16.java
Copy in progress, press [Enter] to cancel it
[##..................]  12 % file1.dat
[#####...............]  25 % file2.dat
[#######.............]  37 % file3.dat
[##########..........]  50 % file4.dat
[############........]  62 % file5.dat
[###############.....]  75 % file6.dat
[#################...]  87 % file7.dat
[####################] 100 % file8.dat
Copy finished: 8 files copied

Ergebnisse, wenn der Benutzer während des Kopiervorgangs nach etwa eineinhalb Sekunden [Enter] eingibt:

1
2
3
4
5
6
7
8
> java Async16.java
Copy in progress, press [Enter] to cancel it
[##..................]  12 % file1.dat
[#####...............]  25 % file2.dat
[#######.............]  37 % file3.dat
[##########..........]  50 % file4.dat
[############........]  62 % file5.dat
Copy cancelled by the user

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:

1
2
3
4
5
6
7
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

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.

// Datei-Ein-/Ausgabe: AsynchronousFileChannel, dann blockierende E/A auf einem virtuellen Thread
final Path data = Path.of("TaxData.txt");
final Path report = Path.of("report-17.txt");

void main() throws InterruptedException {
    // 1 - AsynchronousFileChannel (Java 7): ein asynchrones Lesen, als CompletableFuture zurückgegeben
    String content = readAsynchronously(data).join();
    IO.println("1 - AsynchronousFileChannel: " + content.lines().count() + " lines");

    // 2 bis 7 - gewöhnliche blockierende E/A, von einem virtuellen Thread ausgeführt
    Thread.ofVirtual().start(() -> {
        try {
            processFiles();
        } catch (IOException e) {
            IO.println("error: " + e);
        }
    }).join();
}

// liest eine ganze (kleine) Datei mit einem AsynchronousFileChannel
CompletableFuture<String> readAsynchronously(Path file) {
    CompletableFuture<String> result = new CompletableFuture<>();
    try {
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(file, StandardOpenOption.READ);
        ByteBuffer buffer = ByteBuffer.allocate((int) channel.size());
        // das Lesen wird gestartet; das Callback-Objekt schließt das CompletableFuture ab
        channel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer nbBytes, ByteBuffer read) {
                result.complete(new String(read.array(), 0, nbBytes, StandardCharsets.UTF_8));
            }

            @Override
            public void failed(Throwable e, ByteBuffer read) {
                result.completeExceptionally(e);
            }
        });
        // der Channel wird geschlossen, wenn das Lesen beendet ist, unabhängig vom Ausgang
        result.whenComplete((text, e) -> close(channel));
    } catch (IOException e) {
        result.completeExceptionally(e);
    }
    return result;
}

void processFiles() throws IOException {
    // 2 - die ganze Datei in einer einzigen Operation lesen
    List<String> lines = Files.readAllLines(data);
    IO.println("2 - Files.readAllLines: " + lines.size() + " lines");

    // 3 - zeilenweises Lesen mit einem BufferedReader
    List<TaxBracket> brackets = new ArrayList<>();
    try (BufferedReader reader = Files.newBufferedReader(data)) {
        String line;
        // readLine gibt am Dateiende null zurück
        while ((line = reader.readLine()) != null) {
            brackets.add(TaxBracket.parse(line));
        }
    }
    IO.println("3 - BufferedReader.readLine: " + brackets.size() + " brackets, 2nd: " + brackets.get(1));

    // 4 - Files.lines liefert einen Stream von Zeilen, bei Bedarf gelesen
    try (Stream<String> stream = Files.lines(data)) {
        IO.println("4 - Files.lines: " + stream.count() + " lines");
    }

    // 5 - Schreiben mit einem BufferedWriter
    try (BufferedWriter writer = Files.newBufferedWriter(report)) {
        writer.write("Brackets of the tax scale (exercise: 2004 tax scale on 2003 income)");
        writer.newLine();
        for (int i = 0; i < brackets.size(); i++) {
            TaxBracket bracket = brackets.get(i);
            String limit = bracket.limit().signum() == 0 ? "beyond"
                    : String.format("up to %,d €", bracket.limit().intValue());
            writer.write(String.format("bracket %d : %-18s rate %.1f %%",
                    i + 1, limit, bracket.coeffR().multiply(BigDecimal.valueOf(100))));
            writer.newLine();
        }
    }

    // 6 - die ganze Datei als Zeichenkette lesen
    String text = Files.readString(report);
    IO.print("5 and 6 - content of [" + report + "] :\n" + text);

    // 7 - am Ende der Datei anhängen und sie dann löschen
    Files.writeString(report, "end of the report\n", StandardOpenOption.APPEND);
    IO.println("7 - last line: " + Files.readAllLines(report).getLast());
    Files.delete(report);
}

// schließt einen Channel ohne geprüfte Exception
void close(Channel channel) {
    try {
        channel.close();
    } catch (IOException e) {
        IO.println("error while closing: " + e);
    }
}

// eine Steuerstufe; die Datei verwendet den Dezimalpunkt, den BigDecimal versteht
record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
    static TaxBracket parse(String line) {
        String[] fields = line.split(":");
        return new TaxBracket(new BigDecimal(fields[0]), new BigDecimal(fields[1]),
                new BigDecimal(fields[2]));
    }
}

Ergebnisse:

> java Async17.java
1 - AsynchronousFileChannel: 7 lines
2 - Files.readAllLines: 7 lines
3 - BufferedReader.readLine: 7 brackets, 2nd: TaxBracket[limit=8382, coeffR=0.068, coeffN=291.09]
4 - Files.lines: 7 lines
5 and 6 - content of [report-17.txt] :
Brackets of the tax scale (exercise: 2004 tax scale on 2003 income)
bracket 1 : up to 4,962 €      rate 0.0 %
bracket 2 : up to 8,382 €      rate 6.8 %
bracket 3 : up to 14,753 €     rate 19.1 %
bracket 4 : up to 23,888 €     rate 28.3 %
bracket 5 : up to 38,868 €     rate 37.4 %
bracket 6 : up to 47,932 €     rate 42.6 %
bracket 7 : beyond             rate 48.1 %
7 - last line: end of the report

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:

// HttpClient: asynchrone (sendAsync) oder blockierende (send) HTTP-Anfragen an einen kleinen lokalen Server
import com.sun.net.httpserver.HttpServer;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

final int port = 27510;
final List<String> cities = List.of("Angers", "Brest", "Colmar", "Dijon", "Évry", "Foix");
long start;

void main() throws IOException, InterruptedException, ExecutionException {
    // ein HTTP-Server, der eine Sekunde braucht, um die "Temperatur" einer Stadt zu liefern
    HttpServer server = HttpServer.create(new InetSocketAddress(InetAddress.getLoopbackAddress(), port), 0);
    server.createContext("/temperature", exchange -> {
        // die Anfrage hat die Form /temperature?city=xxx
        String parameter = exchange.getRequestURI().getRawQuery().substring("city=".length());
        String city = URLDecoder.decode(parameter, StandardCharsets.UTF_8);
        sleep(1000);
        byte[] response = (city + " : " + (10 + city.length()) + " °C").getBytes(StandardCharsets.UTF_8);
        exchange.sendResponseHeaders(200, response.length);
        try (OutputStream stream = exchange.getResponseBody()) {
            stream.write(response);
        }
    });
    // jede empfangene Anfrage wird von einem virtuellen Thread bearbeitet
    server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
    server.start();

    try (HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build()) {
        // eine erste Anfrage, damit die JVM die Client-Klassen vor den Messungen lädt
        client.send(request("Paris"), HttpResponse.BodyHandlers.discarding());

        // 1 - sendAsync liefert sofort ein CompletableFuture<HttpResponse<String>>
        start = System.nanoTime();
        List<CompletableFuture<String>> responses = cities.stream()
                .map(city -> client.sendAsync(request(city), HttpResponse.BodyHandlers.ofString())
                        .thenApply(HttpResponse::body))
                .toList();
        CompletableFuture.allOf(responses.toArray(CompletableFuture[]::new)).join();
        display("1 - sendAsync: " + responses.stream().map(CompletableFuture::resultNow).toList());

        // 2 - send ist blockierend: wir rufen es aus virtuellen Threads auf
        start = System.nanoTime();
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> responses2 = new ArrayList<>();
            for (String city : cities) {
                responses2.add(executor.submit(
                        () -> client.send(request(city), HttpResponse.BodyHandlers.ofString()).body()));
            }
            List<String> texts = new ArrayList<>();
            for (Future<String> response : responses2) {
                texts.add(response.get());
            }
            display("2 - send on virtual threads: " + texts);
        }
    } finally {
        server.stop(0);
    }
}

// die GET-Anfrage, die die Temperatur einer Stadt abfragt
HttpRequest request(String city) {
    String parameter = URLEncoder.encode(city, StandardCharsets.UTF_8);
    URI address = URI.create("http://localhost:" + port + "/temperature?city=" + parameter);
    return HttpRequest.newBuilder(address).build();
}

// Thread.sleep ohne geprüfte Exception: eine Unterbrechung wird zu einer CancellationException
void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new CancellationException("wait interrupted");
    }
}

// Ausgabe mit der seit [start] verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

1
2
3
> java Async18.java
 1033 ms : 1 - sendAsync: [Angers : 16 °C, Brest : 15 °C, Colmar : 16 °C, Dijon : 15 °C, Évry : 14 °C, Foix : 14 °C]
 1023 ms : 2 - send on virtual threads: [Angers : 16 °C, Brest : 15 °C, Colmar : 16 °C, Dijon : 15 °C, Évry : 14 °C, Foix : 14 °C]

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>]:

// eine Folge von mit Wartezeiten erzeugten Werten: ein "blockierender" Stream, von einem virtuellen Thread gelesen
long start;

void main() throws InterruptedException {
    // die ganze Arbeit wird von einem virtuellen Thread erledigt: seine Wartezeiten blockieren keinen Carrier-Thread
    Thread.ofVirtual().start(this::consume).join();
}

void consume() {
    start = System.nanoTime();
    // 1 - jeder Wert wird verarbeitet, sobald er erzeugt wird
    try (Stream<Measurement> measurements = readMeasurements("sensor-1", 4)) {
        measurements.forEach(measurement -> display("1 - received " + measurement));
    }

    // 2 - wir können die Schleife vor dem Ende verlassen: der Producer erzeugt die folgenden Werte nicht
    start = System.nanoTime();
    try (Stream<Measurement> measurements = readMeasurements("sensor-2", 100)) {
        Iterator<Measurement> iterator = measurements.iterator();
        while (iterator.hasNext()) {
            Measurement measurement = iterator.next();
            display("2 - received " + measurement);
            if (measurement.value() >= 22) {
                break;
            }
        }
    }

    // 3 - Abbruch: ein anderer Thread unterbricht den Thread, der den Stream liest
    start = System.nanoTime();
    Thread reader = Thread.ofVirtual().start(() -> {
        try (Stream<Measurement> measurements = readMeasurements("sensor-3", 100)) {
            measurements.forEach(measurement -> display("3 - received " + measurement));
        } catch (CancellationException e) {
            display("3 - reading cancelled");
        }
    });
    waitForEnd(reader, 700);

    // 4 - alle Operationen der Stream-API sind auf den Stream anwendbar
    start = System.nanoTime();
    String high;
    try (Stream<Measurement> measurements = readMeasurements("sensor-4", 6)) {
        high = measurements
                .filter(measurement -> measurement.value() > 21)
                .map(measurement -> NumberFormat.getInstance().format(measurement.value()))
                .collect(Collectors.joining(" ; ", "[", "]"));
    }
    display("4 - measurements above 21: " + high);
}

// ein Producer: eine Messung alle 200 ms, nur erzeugt, wenn der Consumer sie anfordert
Stream<Measurement> readMeasurements(String sensor, int count) {
    return IntStream.rangeClosed(1, count)
            .mapToObj(i -> {
                // Warten auf die nächste Messung
                sleep(200);
                return new Measurement(sensor, i, 19.5 + i * 0.75);
            })
            // von close() ausgeführt: beim normalen Ende, nach einem break oder bei Abbruch
            .onClose(() -> IO.println("          " + sensor + " : end of production"));
}

// wartet [timeout] ms auf das Ende eines Threads, unterbricht ihn dann und wartet auf sein Ende
void waitForEnd(Thread thread, long timeout) {
    try {
        thread.join(timeout);
        thread.interrupt();
        thread.join();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// Thread.sleep ohne geprüfte Exception: eine Unterbrechung wird zu einer CancellationException
void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new CancellationException("wait interrupted");
    }
}

// Ausgabe mit der seit [start] verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

// eine Messung
record Measurement(String sensor, int number, double value) {
    @Override
    public String toString() {
        return sensor + " no. " + number + " : " + NumberFormat.getInstance().format(value) + " °C";
    }
}

Ergebnisse:

> java Async19.java
  249 ms : 1 - received sensor-1 no. 1 : 20.25 °C
  455 ms : 1 - received sensor-1 no. 2 : 21 °C
  656 ms : 1 - received sensor-1 no. 3 : 21.75 °C
  857 ms : 1 - received sensor-1 no. 4 : 22.5 °C
          sensor-1 : end of production
  200 ms : 2 - received sensor-2 no. 1 : 20.25 °C
  401 ms : 2 - received sensor-2 no. 2 : 21 °C
  603 ms : 2 - received sensor-2 no. 3 : 21.75 °C
  804 ms : 2 - received sensor-2 no. 4 : 22.5 °C
          sensor-2 : end of production
  201 ms : 3 - received sensor-3 no. 1 : 20.25 °C
  402 ms : 3 - received sensor-3 no. 2 : 21 °C
  602 ms : 3 - received sensor-3 no. 3 : 21.75 °C
          sensor-3 : end of production
  702 ms : 3 - reading cancelled
          sensor-4 : end of production
 1206 ms : 4 - measurements above 21: [21.75 ; 22.5 ; 23.25 ; 24]

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:

// das "Push"-Modell: java.util.concurrent.Flow und SubmissionPublisher (Java 9)
final long start = System.nanoTime();

void main() throws InterruptedException {
    Subscriber screen = new Subscriber("screen", 0, 22);
    Subscriber archive = new Subscriber("archive", 500, Double.MAX_VALUE);
    // der Publisher übergibt die Auslieferung der Werte an einen Executor und hält einen Puffer von 2 Werten pro Abonnent
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        var publisher = new SubmissionPublisher<Measurement>(executor, 2);
        publisher.subscribe(screen);
        publisher.subscribe(archive);
        for (int i = 1; i <= 6; i++) {
            sleep(200);
            // submit wartet, wenn im Puffer eines Abonnenten kein Platz mehr ist; es liefert die geschätzte Verzögerung
            int lag = publisher.submit(new Measurement("sensor-1", i, 19.5 + i * 0.75));
            display("publisher: measurement no. " + i + " published, estimated lag: " + lag);
        }
        // close() signalisiert den Abonnenten das Ende des Stroms: ihre Methode onComplete wird aufgerufen
        display("publisher: end of publication");
        publisher.close();
        // wir warten, bis das Archiv alles verarbeitet hat
        archive.end.await();
    }
}

// ein Abonnent, der jede Messung in [duration] ms verarbeitet und sich oberhalb von [threshold] abmeldet
class Subscriber implements Flow.Subscriber<Measurement> {
    private final String name;
    private final long duration;
    private final double threshold;
    private Flow.Subscription subscription;
    final CountDownLatch end = new CountDownLatch(1);

    Subscriber(String name, long duration, double threshold) {
        this.name = name;
        this.duration = duration;
        this.threshold = threshold;
    }

    @Override
    public void onSubscribe(Flow.Subscription subscription) {
        this.subscription = subscription;
        // der Abonnent fordert die Werte einzeln an: er steuert die Rate
        subscription.request(1);
    }

    @Override
    public void onNext(Measurement measurement) {
        display("  " + name + " : received " + measurement);
        sleep(duration);
        if (measurement.value() >= threshold) {
            display("  " + name + " : threshold reached, unsubscribing");
            subscription.cancel();
        } else {
            subscription.request(1);
        }
    }

    @Override
    public void onError(Throwable e) {
        display("  " + name + " : error " + e);
        end.countDown();
    }

    @Override
    public void onComplete() {
        display("  " + name + " : end of the stream");
        end.countDown();
    }
}

// Thread.sleep ohne geprüfte Exception: eine Unterbrechung wird zu einer CancellationException
void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new CancellationException("wait interrupted");
    }
}

// Ausgabe mit der seit dem Start verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

// eine Messung
record Measurement(String sensor, int number, double value) {
    @Override
    public String toString() {
        return sensor + " no. " + number + " : " + NumberFormat.getInstance().format(value) + " °C";
    }
}

Ergebnisse:

> java Async20.java
  221 ms : publisher: measurement no. 1 published, estimated lag: 1
  269 ms :   archive : received sensor-1 no. 1 : 20.25 °C
  274 ms :   screen : received sensor-1 no. 1 : 20.25 °C
  466 ms : publisher: measurement no. 2 published, estimated lag: 2
  466 ms :   screen : received sensor-1 no. 2 : 21 °C
  667 ms :   screen : received sensor-1 no. 3 : 21.75 °C
  667 ms : publisher: measurement no. 3 published, estimated lag: 3
  770 ms :   archive : received sensor-1 no. 2 : 21 °C
  867 ms : publisher: measurement no. 4 published, estimated lag: 3
  868 ms :   screen : received sensor-1 no. 4 : 22.5 °C
  868 ms :   screen : threshold reached, unsubscribing
 1271 ms :   archive : received sensor-1 no. 3 : 21.75 °C
 1271 ms : publisher: measurement no. 5 published, estimated lag: 3
 1771 ms :   archive : received sensor-1 no. 4 : 22.5 °C
 1772 ms : publisher: measurement no. 6 published, estimated lag: 3
 1772 ms : publisher: end of publication
 2274 ms :   archive : received sensor-1 no. 5 : 23.25 °C
 2775 ms :   archive : received sensor-1 no. 6 : 24 °C
 3276 ms :   archive : end of the stream

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:

// ein Cache von CompletableFutures: eine asynchrone Operation, die meistens schon das Ergebnis hat
void main() {
    var service = new RateService();
    // 1 - aufeinanderfolgende Lesezugriffe: nur der erste Lesezugriff auf eine Währung fragt den Server ab
    for (String code : List.of("EUR", "USD", "EUR", "EUR", "USD", "GBP", "EUR")) {
        long readingStart = System.nanoTime();
        BigDecimal rate = service.readRate(code).join();
        IO.println(String.format("%s : %6s read in %3d ms", code, NumberFormat.getInstance().format(rate),
                (System.nanoTime() - readingStart) / 1_000_000));
    }
    IO.println("1 - server accesses: " + service.nbServerAccesses() + ", readings: " + service.nbReadings());

    // 2 - drei gleichzeitige Lesezugriffe auf dieselbe Währung: sie teilen sich dieselbe Operation
    List<CompletableFuture<BigDecimal>> readings = List.of(
            service.readRate("CHF"), service.readRate("CHF"), service.readRate("CHF"));
    IO.println("2 - same object: " + (readings.get(0) == readings.get(2))
            + ", rate: " + NumberFormat.getInstance().format(readings.get(0).join())
            + ", server accesses: " + service.nbServerAccesses() + ", readings: " + service.nbReadings());

    // 3 - eine fehlgeschlagene Operation wird nicht im Cache behalten
    try {
        service.readRate("XYZ").join();
    } catch (CompletionException e) {
        IO.println("3 - " + e.getCause().getMessage() + ", cached currencies: " + service.cachedCurrencies());
    }
}

class RateService {
    // der Cache enthält die CompletableFutures selbst, abgeschlossen oder in Arbeit
    private final Map<String, CompletableFuture<BigDecimal>> cache = new ConcurrentHashMap<>();
    private final AtomicInteger nbServerAccesses = new AtomicInteger();
    private final AtomicInteger nbReadings = new AtomicInteger();

    CompletableFuture<BigDecimal> readRate(String code) {
        nbReadings.incrementAndGet();
        // ist die Währung im Cache, liefern wir das vorhandene CompletableFuture zurück: es wird kein Objekt erzeugt
        return cache.computeIfAbsent(code, this::readRateFromServer);
    }

    private CompletableFuture<BigDecimal> readRateFromServer(String code) {
        nbServerAccesses.incrementAndGet();
        // simuliert die Abfrage eines entfernten Servers (300 ms)
        CompletableFuture<BigDecimal> reading = new CompletableFuture<Void>()
                .completeOnTimeout(null, 300, TimeUnit.MILLISECONDS)
                .thenApply(nothing -> switch (code) {
                    case "EUR" -> BigDecimal.ONE;
                    case "USD" -> new BigDecimal("1.17");
                    case "GBP" -> new BigDecimal("0.87");
                    case "CHF" -> new BigDecimal("0.94");
                    default -> throw new IllegalArgumentException("unknown currency: " + code);
                });
        // im Fehlerfall entfernen wir die Operation aus dem Cache, damit ein späterer Lesezugriff es erneut versucht
        return reading.whenComplete((rate, e) -> {
            if (e != null) {
                cache.remove(code);
            }
        });
    }

    int nbServerAccesses() {
        return nbServerAccesses.get();
    }

    int nbReadings() {
        return nbReadings.get();
    }

    Set<String> cachedCurrencies() {
        return new TreeSet<>(cache.keySet());
    }
}

Ergebnisse:

> java Async21.java
EUR :      1 read in 363 ms
USD :   1.17 read in 300 ms
EUR :      1 read in   0 ms
EUR :      1 read in   0 ms
USD :   1.17 read in   0 ms
GBP :   0.87 read in 300 ms
EUR :      1 read in   0 ms
1 - server accesses: 3, readings: 7
2 - same object: true, rate: 0.94, server accesses: 4, readings: 10
3 - unknown currency: XYZ, cached currencies: [CHF, EUR, GBP, USD]

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:

// ein "von Hand" abgeschlossenes CompletableFuture: eine Listener-basierte API in eine asynchrone Operation verwandeln
final long start = System.nanoTime();

void main() {
    var thermometer = new Thermometer();
    thermometer.start();

    // 1 - wir warten auf die erste Messung größer oder gleich 21 °C
    double measure = waitForTemperature(thermometer, 21).join();
    display("1 - temperature reached: " + format(measure) + " °C");

    // 2 - dasselbe Warten, auf eine Sekunde begrenzt
    try {
        measure = waitForTemperature(thermometer, 30).orTimeout(1, TimeUnit.SECONDS).join();
        display("2 - temperature reached: " + format(measure) + " °C");
    } catch (CompletionException e) {
        display("2 - 30 °C not reached in one second: " + e.getCause().getClass().getSimpleName());
    }
    thermometer.stop();
}

// verwandelt die Benachrichtigungen des Thermometers in ein CompletableFuture
CompletableFuture<Double> waitForTemperature(Thermometer thermometer, double threshold) {
    // ein CompletableFuture, das wir selbst abschließen werden
    CompletableFuture<Double> result = new CompletableFuture<>();
    // der Listener schließt das CompletableFuture ab, wenn der Schwellenwert erreicht ist
    DoubleConsumer listener = temperature -> {
        if (temperature >= threshold) {
            result.complete(temperature);
        }
    };
    thermometer.addListener(listener);
    // unabhängig davon, wie es endet (Schwellenwert, Timeout, Abbruch), entfernen wir den Listener
    result.whenComplete((temperature, e) -> thermometer.removeListener(listener));
    // das CompletableFuture wird sofort zurückgegeben; es wird später abgeschlossen
    return result;
}

// ein Thermometer, das seine Listener alle 200 ms benachrichtigt (eine API "alten Stils")
class Thermometer {
    private final List<DoubleConsumer> listeners = new CopyOnWriteArrayList<>();
    private final ScheduledExecutorService timer = Executors.newSingleThreadScheduledExecutor();
    private double temperature = 19;

    void addListener(DoubleConsumer listener) {
        listeners.add(listener);
    }

    void removeListener(DoubleConsumer listener) {
        listeners.remove(listener);
    }

    void start() {
        timer.scheduleAtFixedRate(() -> {
            temperature += 0.5;
            IO.println("          measure: " + format(temperature) + " °C");
            listeners.forEach(listener -> listener.accept(temperature));
        }, 200, 200, TimeUnit.MILLISECONDS);
    }

    void stop() {
        timer.shutdown();
    }
}

// eine reelle Zahl im lokalen Format, ohne unnötige Dezimalstellen
String format(double value) {
    return NumberFormat.getInstance().format(value);
}

// Ausgabe mit der seit dem Start verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

> java Async22.java
          measure: 19.5 °C
          measure: 20 °C
          measure: 20.5 °C
          measure: 21 °C
  807 ms : 1 - temperature reached: 21 °C
          measure: 21.5 °C
          measure: 22 °C
          measure: 22.5 °C
          measure: 23 °C
          measure: 23.5 °C
 1809 ms : 2 - 30 °C not reached in one second: TimeoutException

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:

// eine Collection mit begrenzter Anzahl gleichzeitiger Operationen verarbeiten: virtuelle Threads und Semaphore
final AtomicInteger inProgress = new AtomicInteger();

long start;

void main() {
    start = System.nanoTime();
    List<String> pages = IntStream.rangeClosed(1, 9).mapToObj(i -> "page" + i + ".html").toList();
    // höchstens 3 Downloads gleichzeitig: ein Semaphor mit 3 Berechtigungen
    var permits = new Semaphore(3);
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        // ein virtueller Thread pro Seite: sie sind billig, wir können so viele erzeugen, wie es Seiten gibt
        for (String page : pages) {
            executor.submit(() -> {
                // der Thread wartet auf eine Berechtigung (ohne einen Carrier-Thread zu blockieren)
                permits.acquire();
                try {
                    download(page);
                } finally {
                    permits.release();
                }
                return null;
            });
        }
    } // close() wartet auf das Ende aller Downloads
    display("the " + pages.size() + " pages are downloaded");
}

void download(String page) throws InterruptedException {
    // von den gleichzeitigen Operationen geteilter Zähler: wir ändern ihn atomar
    int n = inProgress.incrementAndGet();
    display("start of " + page + " (" + n + " in progress)");
    // der simulierte Download einer Seite
    Thread.sleep(1000);
    inProgress.decrementAndGet();
    display("end of " + page);
}

// Ausgabe mit der seit dem Start verstrichenen Zeit und dem Thread, der die Ausgabe ausführt
void display(String message) {
    Thread thread = Thread.currentThread();
    String name = thread.isVirtual() ? "virtual #" + thread.threadId() : thread.getName();
    IO.println(String.format("%5d ms [%-11s] : %s", (System.nanoTime() - start) / 1_000_000, name, message));
}

Ergebnisse:

> java Async23.java
   13 ms [virtual #25] : start of page2.html (2 in progress)
   13 ms [virtual #27] : start of page3.html (3 in progress)
   13 ms [virtual #23] : start of page1.html (1 in progress)
 1026 ms [virtual #25] : end of page2.html
 1026 ms [virtual #27] : end of page3.html
 1026 ms [virtual #23] : end of page1.html
 1026 ms [virtual #28] : start of page4.html (1 in progress)
 1027 ms [virtual #29] : start of page5.html (2 in progress)
 1027 ms [virtual #30] : start of page6.html (3 in progress)
 2027 ms [virtual #29] : end of page5.html
 2027 ms [virtual #30] : end of page6.html
 2028 ms [virtual #31] : start of page7.html (1 in progress)
 2028 ms [virtual #32] : start of page8.html (2 in progress)
 2027 ms [virtual #28] : end of page4.html
 2028 ms [virtual #33] : start of page9.html (3 in progress)
 3028 ms [virtual #31] : end of page7.html
 3028 ms [virtual #32] : end of page8.html
 3029 ms [virtual #33] : end of page9.html
 3030 ms [main       ] : the 9 pages are downloaded

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:

// Producer / Consumer mit einer blockierenden Warteschlange, von virtuellen Threads ausgeführt
// der Wert, der den Consumern signalisiert, dass es keine Bestellungen mehr geben wird
static final int END = -1;
// eine begrenzte Warteschlange: sie enthält höchstens 2 auf Bearbeitung wartende Bestellungen
final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(2);
long start;

void main() {
    start = System.nanoTime();
    // der Producer und zwei Consumer arbeiten gleichzeitig
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        executor.submit(() -> produce(8));
        executor.submit(() -> consume("C1"));
        executor.submit(() -> consume("C2"));
    }
    display("all the orders have been processed");
}

// der Producer: eine Bestellung alle 50 ms
Void produce(int nbOrders) throws InterruptedException {
    for (int i = 1; i <= nbOrders; i++) {
        Thread.sleep(50);
        // offer legt die Bestellung sofort ab, wenn in der Warteschlange Platz ist
        if (queue.offer(i)) {
            display("P  : order " + i + " queued");
        } else {
            // Warteschlange voll: put wartet, bis ein Platz frei wird
            display("P  : queue full, order " + i + " waits");
            queue.put(i);
            display("P  : order " + i + " queued");
        }
    }
    // es wird nichts mehr erzeugt: wir legen die Endmarkierung ab
    queue.put(END);
    display("P  : end of production");
    return null;
}

// ein Consumer: die Bearbeitung einer Bestellung dauert 400 ms
Void consume(String name) throws InterruptedException {
    while (true) {
        // take wartet, bis eine Bestellung in der Warteschlange ist
        int order = queue.take();
        if (order == END) {
            // wir legen die Endmarkierung für den anderen Consumer wieder in die Warteschlange
            queue.put(END);
            break;
        }
        display(name + " : processing of order " + order);
        Thread.sleep(400);
    }
    display(name + " : no more orders");
    return null;
}

// Ausgabe mit der seit dem Start verstrichenen Zeit
void display(String message) {
    IO.println(String.format("%5d ms : %s", (System.nanoTime() - start) / 1_000_000, message));
}

Ergebnisse:

> java Async24.java
   58 ms : P  : order 1 queued
   62 ms : C1 : processing of order 1
  118 ms : C2 : processing of order 2
  119 ms : P  : order 2 queued
  169 ms : P  : order 3 queued
  220 ms : P  : order 4 queued
  271 ms : P  : queue full, order 5 waits
  469 ms : P  : order 5 queued
  469 ms : C1 : processing of order 3
  519 ms : C2 : processing of order 4
  519 ms : P  : order 6 queued
  570 ms : P  : queue full, order 7 waits
  870 ms : C1 : processing of order 5
  870 ms : P  : order 7 queued
  920 ms : C2 : processing of order 6
  920 ms : P  : order 8 queued
 1270 ms : C1 : processing of order 7
 1271 ms : P  : end of production
 1320 ms : C2 : processing of order 8
 1672 ms : C1 : no more orders
 1721 ms : C2 : no more orders
 1721 ms : all the orders have been processed

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:

// Zeit: ScheduledExecutorService und Clock
void main() throws InterruptedException {
    // 1 - eine Aktion alle 500 ms, nach 2,2 Sekunden gestoppt
    long start = System.nanoTime();
    AtomicInteger nbTicks = new AtomicInteger();
    try (ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor()) {
        // scheduleAtFixedRate: erster Tick in 500 ms, dann ein Tick alle 500 ms
        ScheduledFuture<?> ticks = scheduler.scheduleAtFixedRate(
                () -> IO.println(String.format("%6d ms : tick no. %d",
                        (System.nanoTime() - start) / 1_000_000, nbTicks.incrementAndGet())),
                500, 500, TimeUnit.MILLISECONDS);
        // schedule: eine einzelne Aktion in 2,2 Sekunden, die die Ticks stoppt
        ScheduledFuture<?> stop = scheduler.schedule(
                () -> ticks.cancel(false), 2200, TimeUnit.MILLISECONDS);
        stop.get();
        IO.println(String.format("%6d ms : timer stopped after %d ticks",
                (System.nanoTime() - start) / 1_000_000, nbTicks.get()));
    } catch (ExecutionException e) {
        IO.println("error: " + e.getCause());
    }

    // 2 - Clock: eine Klasse, die von der Zeit abhängt, erhält ihre Uhr, statt LocalDateTime.now() aufzurufen
    Clock morning = Clock.fixed(Instant.parse("2026-10-03T09:30:00Z"), ZoneOffset.UTC);
    Clock evening = Clock.fixed(Instant.parse("2026-10-03T19:45:00Z"), ZoneOffset.UTC);
    IO.println(new Reception(morning).greet("Pierre"));
    IO.println(new Reception(evening).greet("Pierre"));
    IO.println(new Reception(Clock.systemDefaultZone()).greet("Pierre") + " (system clock)");
}

// eine Klasse, die von der aktuellen Zeit abhängt
record Reception(Clock clock) {
    String greet(String name) {
        LocalDateTime now = LocalDateTime.now(clock);
        String greeting = now.getHour() < 18 ? "Hello" : "Good evening";
        String date = now.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm"));
        return "[" + date + "] " + greeting + " " + name;
    }
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> java Async25.java
   504 ms : tick no. 1
  1003 ms : tick no. 2
  1503 ms : tick no. 3
  2003 ms : tick no. 4
  2204 ms : timer stopped after 4 ticks
[03/10/2026 09:30] Hello Pierre
[03/10/2026 19:45] Good evening Pierre
[03/10/2026 19:18] Good evening Pierre (system clock)

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:

// strukturierte Nebenläufigkeit: Preview-API in Java 25
// Ausführung: java --enable-preview StructuredConcurrency.java
import java.util.concurrent.StructuredTaskScope.Joiner;
import java.util.concurrent.StructuredTaskScope.Subtask;

void main() throws InterruptedException {
    // 1 - zwei Teilaufgaben, die beide erfolgreich sein müssen
    try (var scope = StructuredTaskScope.open()) {
        Subtask<Integer> angers = scope.fork(() -> readTemperature("Angers", 1000));
        Subtask<Integer> brest = scope.fork(() -> readTemperature("Brest", 500));
        // join wartet auf das Ende der Teilaufgaben; schlägt eine fehl, wird die andere abgebrochen
        // und join wirft eine Exception
        scope.join();
        IO.println("Angers: " + angers.get() + ", Brest: " + brest.get());
    }
    // 2 - die erste Antwort genügt: die anderen Teilaufgaben werden abgebrochen
    try (var scope = StructuredTaskScope.open(Joiner.<Integer>anySuccessfulResultOrThrow())) {
        scope.fork(() -> readTemperature("mirror-paris", 800));
        scope.fork(() -> readTemperature("mirror-lyon", 300));
        IO.println("first answer: " + scope.join());
    }
}

int readTemperature(String city, long duration) throws InterruptedException {
    Thread.sleep(duration);
    return 10 + city.length();
}

Ergebnisse:

1
2
3
> java --enable-preview StructuredConcurrency.java
Angers: 16, Brest: 15
first answer: 21

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]:

1
2
3
4
5
6
7
y 2 60000
y 3 60000
n 0 60000
n 2 25000
y 5 120000
x 1 20000
y 1 -5

(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.

// Anwendung: die Steuerberechnung, mit von virtuellen Threads ausgeführter Ein-/Ausgabe
// - die Stufen werden aus [TaxData.txt] gelesen, die Steuerpflichtigen aus [taxpayers.txt]
// - die Ergebnisse werden in [results.txt] geschrieben
// eine korrekte Zeile eines Steuerpflichtigen: verheiratet (y/n), Anzahl der Kinder, Jahresgehalt
static final Pattern TAXPAYER = Pattern.compile("([yn])\\s+(\\d+)\\s+(\\d+)");

void main() {
    Path results = Path.of("results.txt");
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        // die beiden Eingabedateien werden gleichzeitig von zwei virtuellen Threads gelesen
        Future<List<TaxBracket>> bracketsReading = executor.submit(
                () -> loadBrackets(Path.of("TaxData.txt")));
        Future<List<String>> taxpayersReading = executor.submit(
                () -> Files.readAllLines(Path.of("taxpayers.txt")));
        // die Berechnung wartet auf die beiden Lesevorgänge und schreibt dann die Ergebnisse
        Future<Integer> processing = executor.submit(
                () -> calculateTaxes(bracketsReading.get(), taxpayersReading.get(), results));
        try {
            // die gesamte Verarbeitung ist auf 10 Sekunden begrenzt
            int nbResults = processing.get(10, TimeUnit.SECONDS);
            IO.println(nbResults + " lines written in [" + results + "] :");
            IO.print(Files.readString(results));
        } catch (TimeoutException e) {
            processing.cancel(true);
            IO.println("processing abandoned: timeout exceeded");
        }
    } catch (ExecutionException e) {
        // der Fehler eines Lesevorgangs wird doppelt eingepackt: vom Lesen und von der Berechnung, die darauf gewartet hat
        Throwable cause = e.getCause();
        while (cause instanceof ExecutionException) {
            cause = cause.getCause();
        }
        IO.println("error: " + cause.getClass().getSimpleName() + " : " + cause.getMessage());
    } catch (IOException | InterruptedException e) {
        IO.println("error: " + e.getClass().getSimpleName() + " : " + e.getMessage());
    }
}

// liest die Steuerstufen (limit:coeffR:coeffN, Dezimalpunkt)
List<TaxBracket> loadBrackets(Path file) throws IOException {
    try (Stream<String> lines = Files.lines(file)) {
        return lines.filter(line -> !line.isBlank()).map(TaxBracket::parse).toList();
    }
}

// berechnet die Steuer jedes Steuerpflichtigen und schreibt die Ergebnisse
int calculateTaxes(List<TaxBracket> brackets, List<String> taxpayers, Path output) throws IOException {
    try (BufferedWriter writer = Files.newBufferedWriter(output)) {
        for (String line : taxpayers) {
            Matcher fields = TAXPAYER.matcher(line.trim());
            String result = fields.matches()
                    ? "tax = " + calculateTax(brackets, fields.group(1).equals("y"),
                            Integer.parseInt(fields.group(2)), Integer.parseInt(fields.group(3))) + " €"
                    : "incorrect line";
            writer.write(String.format("%-12s : %s", line, result));
            writer.newLine();
        }
    }
    return taxpayers.size();
}

// die Steuerberechnung (Steuertarif 2004 auf Einkommen 2003, für die Übung beibehalten)
int calculateTax(List<TaxBracket> brackets, boolean married, int nbChildren, int salary) {
    BigDecimal shares = BigDecimal.valueOf(nbChildren).divide(BigDecimal.TWO)
            .add(BigDecimal.valueOf(married ? 2 : 1));
    if (nbChildren >= 3) {
        shares = shares.add(new BigDecimal("0.5"));
    }
    BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));
    BigDecimal quotient = income.divide(shares, MathContext.DECIMAL64);
    // die erste Stufe, deren Grenze den Familienquotienten übersteigt, andernfalls die letzte
    TaxBracket bracket = brackets.stream()
            .filter(t -> quotient.compareTo(t.limit()) <= 0)
            .findFirst()
            .orElse(brackets.getLast());
    return bracket.coeffR().multiply(income).subtract(bracket.coeffN().multiply(shares)).intValue();
}

// eine Steuerstufe
record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
    static TaxBracket parse(String line) {
        String[] fields = line.split(":");
        return new TaxBracket(new BigDecimal(fields[0]), new BigDecimal(fields[1]),
                new BigDecimal(fields[2]));
    }
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> java Async26.java
7 lines written in [results.txt] :
y 2 60000    : tax = 4282 €
y 3 60000    : tax = 2959 €
n 0 60000    : tax = 11519 €
n 2 25000    : tax = 792 €
y 5 120000   : tax = 11109 €
x 1 20000    : incorrect line
y 1 -5       : incorrect line

Dasselbe Programm, ausgeführt in einem Ordner, in dem die Datei [TaxData.txt] fehlt:

> java Async26.java
error: NoSuchFileException : TaxData.txt

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).