Skip to content

9. Asynchrone Programmierung mit Coroutinen

Das vorherige Kapitel hat Threads eingeführt: Sie können mehrere Codeabschnitte „gleichzeitig“ ausführen, 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 blockieren.

In diesem Kapitel weicht Kotlin am stärksten von Java ab. Der Java-Kurs hat zwei Lösungen vorgestellt: die Klasse [CompletableFuture<T>], deren Verhalten über Callback-Methoden erweitert wird, und die virtuellen Threads von Java 21, die es erlauben, blockierenden Code zu schreiben, ohne Systemthreads zu blockieren. Beide Werkzeuge stehen in Kotlin weiterhin zur Verfügung (es sind Klassen des JDK), und wir werden auf sie zurückkommen. Kotlin bietet jedoch eine eigene Lösung: Coroutinen:

  • Die Sprache enthält nur ein einziges Schlüsselwort, [suspend], das eine Suspend-Funktion kennzeichnet: eine Funktion, die mitten in ihrer Ausführung pausieren, den ausführenden Thread freigeben und später an derselben Stelle mit denselben Werten der lokalen Variablen fortgesetzt werden kann;
  • der Compiler wandelt jede Suspend-Funktion in eine „Zustandsmaschine“ um, die pausieren und fortsetzen kann; wir werden sehen, wie;
  • Alles andere stellt eine Bibliothek bereit, kotlinx.coroutines: Coroutinen starten ([launch], [async]), auf sie warten ([join], [await]), ohne Blockierung warten ([delay]), die Threads wählen, die sie ausführen (die Dispatcher), sie abbrechen, ihre Dauer begrenzen und Werte zwischen ihnen austauschen ([Flow], [Channel]).

Der resultierende Code liest sich von oben nach unten wie sequenzieller Code: Er entspricht den C#-Schlüsselwörtern [async] / [await], die die Leser des ursprünglichen Kurses kennen, plus einem Konzept, das weder C# noch Java (außer in einer Vorstufe) bietet: strukturierte Nebenläufigkeit, die Coroutinen in einem Baum organisiert, in dem jeder Knoten auf seine Kinder wartet, sie abbricht und ihre Fehler empfängt.

Coroutinen sind inzwischen im gesamten Kotlin-Ökosystem allgegenwärtig: auf Android, in Web-Frameworks (Ktor, Spring, das in seinen Controllern [suspend]-Funktionen akzeptiert), in HTTP-Clients und in Datenbanktreibern. Die folgenden Kapitel verwenden sie für den Zugriff auf Datenbanken und das Netzwerk.

Die Bibliothek kotlinx.coroutines ist nicht Teil der Standardbibliothek: Das Gradle-Projekt dieses Kapitels im Ordner [09-async] deklariert sie in seiner Datei [build.gradle.kts]:

// Kapitel 9: asynchrone Programmierung mit Coroutinen
plugins {
    kotlin("jvm") version "2.4.20"
    application
}

group = "examples"
version = "1.0"

repositories {
    mavenCentral()
}

dependencies {
    // die von den Programmen des Projekts verwendeten Bibliotheken
    // Kotlin-Coroutinen
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0")
}

kotlin {
    // der Code wird mit JDK 25 kompiliert und ausgeführt
    jvmToolchain(25)
    compilerOptions {
        // eine Compiler-Warnung wird als Fehler behandelt
        allWarningsAsErrors = true
        // die Namen der Funktionsparameter bleiben im Bytecode erhalten
        javaParameters = true
    }
}

application {
    // das von [gradlew run] ausgeführte Programm wird durch die Eigenschaft [main] angegeben:
    // gradlew -q run -Pmain=async01.Async01Kt
    mainClass = providers.gradleProperty("main").orElse("async01.Async01Kt")
}

tasks.named<JavaExec>("run") {
    // das laufende Programm kann die Tastatur lesen
    standardInput = System.`in`
}

// unter Windows wird die Bildschirmausgabe des von Gradle gestarteten Programms (run, bootRun ...) in UTF-8 kodiert,
// sonst werden Zeichen mit Akzenten in der IntelliJ-IDEA-Konsole oder im Terminal falsch dargestellt
tasks.withType<JavaExec>().configureEach {
    jvmArgs("-Dstdout.encoding=UTF-8", "-Dstderr.encoding=UTF-8")
}
  • Zeile 17: die Abhängigkeit von der Bibliothek kotlinx.coroutines, Version 1.11.0. Das Hauptpaket ist [kotlinx.coroutines];
  • Zeilen 32–34: Wie in den vorherigen Kapiteln wird das auszuführende Programm über die Eigenschaft [main] angegeben: [gradlew -q run -Pmain=async01.Async01Kt];
  • Zeilen 42–45: Die von Gradle gestarteten Programme schreiben ihre Ausgabe in UTF-8, damit Zeichen mit Akzenten unter Windows korrekt angezeigt werden (Kapitel 2).

Die Programme dieses Kapitels sind wie üblich in Paketen organisiert, die nach ihnen benannt sind: [src/main/kotlin/async01/Async01.kt], [src/main/kotlin/async02/Async02.kt] … Viele davon messen Zeiten mit [System.nanoTime()]: Die angezeigten Millisekunden schwanken von einem Lauf zum anderen und von einem Rechner zum anderen (die Beispiele wurden auf einem Rechner mit zwei Prozessoren ausgeführt). Entscheidend sind die Größenordnungen: 1 Sekunde oder 10 Sekunden, 300 ms oder 0 ms. Die erste Verwendung von Coroutinen in einem Programm lädt die Klassen der Bibliothek, was die ersten Messungen oft um einige zehn Millisekunden verlängert.

9.1. Warum Asynchronität

9.1.1. Operationen, die warten

Ein Programm erledigt 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 darin besteht, auf ein Gerät zu warten: eine Datei von der Festplatte lesen, eine Anfrage an einen Webserver senden und auf dessen Antwort warten, eine SQL-Abfrage auf einem Datenbankserver ausführen.

Die Größenordnungen sind sehr unterschiedlich. Ein Prozessor führt einige Milliarden Befehle pro Sekunde aus. Ein Lesevorgang auf einer Festplatte (SSD) dauert etwa eine Zehntelmillisekunde; eine Hin- und Rückreise im lokalen Netzwerk dauert den Bruchteil einer Millisekunde; eine Hin- und Rückreise zu einem Server am anderen Ende des Landes dauert einige zehn Millisekunden; und eine etwas komplexe SQL-Anfrage kann manchmal mehrere Sekunden dauern. Während dieser Wartezeiten hätte der Prozessor Millionen von Befehlen ausführen können.

Wenn ein Programm mit einer blockierenden Funktion eine Zeile über eine Netzwerkverbindung liest, ist der Thread, der dieses Lesen ausführt, blockiert: Er tut nichts, existiert aber weiterhin. Ein „klassischer“ JVM-Thread – heute als „Plattform-Thread“ bezeichnet – ist ein Thread des Betriebssystems: Er belegt Speicher (seinen Stack, in der Größenordnung von einem Megabyte), ist dem System bekannt und steht vor allem nicht mehr für andere Aufgaben zur Verfügung. In einem kleinen Konsolenprogramm, das jeweils nur eine Sache erledigt, ist das kein Problem. In zwei Situationen ist es dagegen ein viel größeres Problem:

  • 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 kein Thread für einen neuen Client übrig. Ein moderner Server verarbeitet Tausende gleichzeitiger Anfragen: Das ist möglich, weil seine Warteoperationen keine Systemthreads binden;
  • in einer grafischen Benutzeroberfläche: Ein einzelner Thread – der UI-Thread (der Hauptthread einer Android-App, der „Event Dispatch Thread“ von Swing, der „JavaFX Application Thread“) – verarbeitet Klicks und zeichnet Fenster neu. Wird er durch einen Download blockiert, friert das Fenster ein; unter Android fordert das System den Benutzer schließlich sogar auf, die App zu schließen.

Asynchronität bedeutet, die E/A-Operation zu starten, den Systemthread während ihrer Ausführung freizugeben (die Hardware und das Betriebssystem benötigen ihn nicht für die Datenübertragung) und die Arbeit nach Abschluss der Operation fortzusetzen, gegebenenfalls in einem anderen Thread. Die virtuellen Threads von Java erreichen dies auf JVM-Ebene: Ein blockierter virtueller Thread wird von seinem Trägerthread getrennt, der in der Zwischenzeit andere virtuelle Threads ausführt. Kotlin-Coroutinen erreichen dies auf der Ebene des kompilierten Codes: Eine wartende Coroutine wird suspendiert, das heißt, ihr Zustand (wo sie stehen geblieben ist, und ihre lokalen Variablen) wird in einem Heap-Objekt namens Continuation gespeichert, und der Thread, der sie ausgeführt hat, geht zurück an seinen Pool:

Image

  • In [1]führt der Systemthread T1 eine blockierende Funktion aus; er bleibt blockiert, bis die E/A abgeschlossen ist;
  • In [2]ruft die Coroutine C1 eine Suspend-Funktion auf, die die E/A startet; die Coroutine wird suspendiert: Ihre Continuation wird auf dem Heap gespeichert, und der Thread T1, der sie ausgeführt hat, kann sofort andere Coroutinen ausführen. Wenn die E/A abgeschlossen ist, wird die Continuation von einem freien Thread T2 (das könnte auch T1 sein) fortgesetzt, und C1 setzt ihre Ausführung unmittelbar nach dem Aufruf der Suspend-Funktion fort, als wäre nichts geschehen.

Das Programm [Async01.kt] 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 ([runBlocking], [launch], [delay]): Hier interessieren uns vor allem die Ergebnisse.

// Warum Asynchronität: 100 Operationen, die jeweils eine Sekunde warten
// (ein Warten simuliert eine E/A-Operation: Lesen von Datenträger, Netzwerkanfrage, SQL-Abfrage …)
package async01

import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import java.lang.management.ManagementFactory
import java.util.concurrent.Executors
import kotlin.concurrent.thread

const val NB_OPERATIONS = 100
var start = 0L

fun main() {
    val nbProcessors = Runtime.getRuntime().availableProcessors()
    println("$NB_OPERATIONS one-second operations, $nbProcessors processors")

    // 1 - ein Plattform-Thread pro Operation, jeder Thread ist während des Wartens blockiert
    start = System.nanoTime()
    val threads = List(NB_OPERATIONS) { thread { Thread.sleep(1000) } }
    waitUntilHalfway()
    display("1 - one platform thread per operation", jvmThreads())
    threads.forEach { it.join() }
    display("    end")

    // 2 - die Operationen werden an einen Pool mit 10 Threads übergeben, blockieren ihn aber
    start = System.nanoTime()
    Executors.newFixedThreadPool(10).use { pool ->
        repeat(NB_OPERATIONS) { pool.execute { Thread.sleep(1000) } }
        waitUntilHalfway()
        display("2 - pool of 10 threads, blocking waits", jvmThreads())
    } // close() wartet auf das Ende aller Operationen
    display("    end")

    // 3 - ein virtueller Thread pro Operation: er gibt seinen Carrier-Thread während des Wartens frei
    start = System.nanoTime()
    Executors.newVirtualThreadPerTaskExecutor().use { executor ->
        repeat(NB_OPERATIONS) { executor.execute { Thread.sleep(1000) } }
        waitUntilHalfway()
        display("3 - one virtual thread per operation", jvmThreads())
    }
    display("    end")

    // 4 - eine Coroutine pro Operation: delay setzt die Coroutine aus, ohne einen Thread zu blockieren
    start = System.nanoTime()
    runBlocking {
        repeat(NB_OPERATIONS) { launch { delay(1000) } }
        // ein Warten, das ebenfalls aussetzt: der Thread bleibt für die Coroutinen verfügbar
        delay(500 - elapsed())
        display("4 - one coroutine per operation", jvmThreads())
    } // runBlocking wartet auf das Ende aller von ihm gestarteten Coroutinen
    display("    end")

    // 5 - hunderttausend Coroutinen, weiterhin auf dem einzigen Thread [main]
    start = System.nanoTime()
    runBlocking {
        repeat(100_000) { launch { delay(1000) } }
        delay(500 - elapsed())
        display("5 - 100,000 coroutines", jvmThreads())
    }
    display("    end")
}

// seit [start] verstrichene Millisekunden
fun elapsed(): Long = (System.nanoTime() - start) / 1_000_000

// blockierendes Warten bis 500 ms nach [start]
fun waitUntilHalfway() {
    val remaining = 500 - elapsed()
    if (remaining > 0) Thread.sleep(remaining)
}

// Anzahl der lebenden Plattform-Threads der JVM
fun jvmThreads(): Int = ManagementFactory.getThreadMXBean().threadCount

// Anzeige der verstrichenen Zeit und, falls angegeben (>= 0), der Anzahl der Threads
fun display(message: String, nbThreads: Int = -1) {
    val threadsInfo = if (nbThreads < 0) "" else ", %3d threads in the JVM".format(nbThreads)
    println("%-44s : %5d ms%s".format(message, elapsed(), threadsInfo))
}

Ergebnisse:

> gradlew -q run -Pmain=async01.Async01Kt
100 one-second operations, 2 processors
1 - one platform thread per operation        :   530 ms, 106 threads in the JVM
    end                                      :  1035 ms
2 - pool of 10 threads, blocking waits       :   500 ms,  16 threads in the JVM
    end                                      : 10009 ms
3 - one virtual thread per operation         :   501 ms,  10 threads in the JVM
    end                                      :  1014 ms
4 - one coroutine per operation              :   504 ms,  10 threads in the JVM
    end                                      :  1059 ms
5 - 100,000 coroutines                       :   501 ms,  10 threads in the JVM
    end                                      :  1341 ms

Kommentare:

  • Zeilen 19–25: Die einfachste Lösung – ein Plattform-Thread pro Operation. Die Funktion [thread { … }] aus [kotlin.concurrent] (Kapitel 8) erzeugt und startet einen Thread; [List(NB_OPERATIONS) { … }] erstellt die Liste der 100 Threads. 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 zählt 106 (Zeile 3). Bei 10 000 Operationen wären 10 000 Systemthreads nötig;
  • Zeilen 27–34: Die Operationen werden einem Pool von 10 Threads zugewiesen ([Executors.newFixedThreadPool(10)]), einer für Berechnungen vernünftigen Größe. Hier führen diese Threads jedoch keine Berechnungen aus – sie warten 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. Ein [ExecutorService] ist [AutoCloseable] (Java 19): Die Funktion [use] ruft am Ende des Blocks seine Methode [close()] auf, die neue Aufgaben ablehnt und auf den Abschluss der bereits übergebenen wartet ([use] übernimmt dieselbe Rolle wie [try] mit einer Java-Ressource);
  • Zeilen 36–43: ein virtueller Thread pro Operation. Der Code der Aufgabe ist derselbe wie in Schritt 1: ein blockierendes [Thread.sleep(1000)]. Ein blockierter virtueller Thread blockiert jedoch keinen Systemthread. Die 100 Wartevorgänge dauern zusammen eine Sekunde (Zeile 8), und die JVM hat nur 10 Systemthreads (Zeile 7): ihre Servicethreads und die beiden Trägerthreads, einen pro Prozessor. Dies ist die Lösung aus dem Java-Kurs;
  • Zeilen 45–53: eine Coroutine pro Operation. [runBlocking { … }] führt einen Codeblock als Coroutine auf dem Thread aus, der es aufruft (hier der Thread [main]), und gibt die Kontrolle erst am Ende dieser Coroutine und aller von ihr gestarteten Coroutinen zurück. Innerhalb des Blocks [launch { delay(1000) }] startet eine neue Coroutine, die eine Sekunde wartet: [delay] ist eine Suspend-Funktion, die die Coroutine suspendiert, ohne den Thread zu blockieren. Die 100 Coroutinen werden vom einzigen Thread [main] ausgeführt: Während sie warten, schuldet er ihnen nichts und führt die anderen aus. Die JVM hat weiterhin 10 Threads (Zeile 9): keinen mehr als im vorherigen Schritt. Der gesamte Vorgang dauert etwas mehr als eine Sekunde (Zeile 10); die zusätzliche Zeit stammt vom Laden der Bibliotheksklassen, das bei dieser ersten Verwendung erfolgt;
  • Zeile 50: Um die Anzahl der Threads auf halber Strecke zu messen, wartet auch die Haupt-Coroutine mit [delay]. Mit [Thread.sleep]würde sie den Thread [main]blockieren, der als einziger die 100 Coroutinen ausführt: Sie könnten erst nach Ende dieses Wartens starten. Wir kommen auf diesen entscheidenden Unterschied zwischen [delay] und [Thread.sleep] zurück;
  • Zeilen 55–62: einhunderttausend Coroutinen, weiterhin ausschließlich vom Thread [main] ausgeführt, ohne zusätzliche Threads (Zeile 11). Eine suspendierte Coroutine ist lediglich eine kleine Menge von Heap-Objekten mit jeweils einigen Dutzend Bytes: Es kann Hunderttausende davon geben. Das Erzeugen der 100 000 Coroutinen und ihrer Timeouts dauert selbst etwas (einige hundert Millisekunden auf dem Beispielrechner, daher die Zeit in Zeile 12); 100 000 Plattform-Threads könnte man dagegen auf den meisten Rechnern schlicht nicht erzeugen;
  • Zeile 75: [ManagementFactory.getThreadMXBean().threadCount] gibt die Anzahl der lebenden Plattform-Threads der JVM zurück. In Kotlin wird die Java-Methode [getThreadCount()] als Eigenschaft [threadCount] behandelt;
  • Die Funktion [thread] und ihre Executors verwenden [Thread.sleep] direkt: Kotlin kennt keine geprüften Ausnahmen (Kapitel 3), sodass die [InterruptedException] , die [Thread.sleep] auslösen könnte, nicht abgefangen werden muss, wie es die Methode [waitFor] im Java-Programm tat.

Merken wir uns die Lektion: Um zu warten, darf man keine Systemthreads blockieren. Asynchronität macht E/A nicht schneller; sie erlaubt es, viele E/A-Operationen gleichzeitig mit wenigen Threads zu bewältigen und die Threads, die die Anwendung braucht, verfügbar zu halten. Kotlin bietet zwei Ansätze: gewöhnlichen blockierenden Code zu schreiben, der von virtuellen Threads ausgeführt wird (Schritt 3, wie in Java), oder Suspend-Funktionen zu schreiben, die von Coroutinen ausgeführt werden (Schritte 4 und 5). Dieses Kapitel konzentriert sich auf den zweiten Ansatz.

9.1.2. Mehrere aufeinanderfolgende Modelle

Die Plattformen haben mehrere Möglichkeiten geboten, Code zu schreiben, der wartet, ohne zu blockieren. Die ältesten findet man noch in bestehendem Code, und Kotlin – das Java-Bibliotheken direkt verwendet – arbeitet neben ihnen: Es ist nützlich, sie zu erkennen.

Modell
Erscheinungsjahr
Prinzip
Threads und Executors
Java 1.0 (1996), Java 5 (2004)
ein Thread pro Operation oder ein Thread-Pool ([ExecutorService]). [submit] gibt ein [Future<T>] zurück, das das künftige Ergebnis repräsentiert, aber dieses Ergebnis erhält man nur, indem man blockierend mit [get()] wartet.
Callback-Methoden
Java 7 (NIO.2, 2011), JavaScript
Eine Operation wird gestartet, indem ihr ein Objekt oder eine Callback-Funktion übergeben wird ([CompletionHandler] aus NIO.2), die am Ende der Operation von einem Thread aus einem Pool aufgerufen wird.
komponierbare Futures
Java 8 ([CompletableFuture], 2014), Promises aus JavaScript
ein Objekt, das die laufende Operation repräsentiert und dessen Folgeschritte mit Methoden zusammengesetzt werden ([thenApply], [thenCompose], [exceptionally] …); reaktive Bibliotheken (Project Reactor, RxJava) beruhen auf denselben Ideen.
[async] / [await]
C# 5 (2012), gefolgt von JavaScript, Python, Rust …
[async]-Methoden, die eine Task zurückgeben ([Task<T>] in C#); [await] suspendiert die Methode, bis die Task abgeschlossen ist, ohne den Thread zu blockieren. Der Compiler wandelt die Methode in eine Zustandsmaschine um.
Kotlin-Coroutinen
Kotlin 1.3 (2018)
Funktionen wie [suspend] werden vom Compiler in Zustandsmaschinen umgewandelt, und die Bibliothek kotlinx.coroutines stellt strukturierte Nebenläufigkeit bereit. Aufrufe von Suspend-Funktionen enthalten keine Schlüsselwörter: Der Code hat die Form von sequenziellem Code.
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.

Callback-Methoden haben einen Nachteil: Der Code wird in Stücke zerlegt. Was sich natürlich als „verbinden, dann lesen, dann anzeigen“ liest, wird zu einer Funktion, die die Verbindung startet, einer Callback-Funktion, die das Lesen startet, und einer weiteren Callback-Funktion, die die Daten anzeigt; Variablen müssen zwischen diesen Funktionen geteilt werden, Ausnahmen werden an verschiedenen Stellen abgefangen, und eine einfache Schleife („lesen, solange Daten vorhanden sind“) wird zu einer Callback-Funktion, die sich rekursiv selbst aufruft. Komponierbare Futures machen diese Zerstückelung lesbarer, indem sie die Schritte verketten; Coroutinen beseitigen sie vollständig: Asynchroner Code hat die Form von synchronem Code. Der Unterschied zu virtuellen Threads besteht darin, dass der Compiler – nicht die JVM – den Code an den Wartepunkten aufteilt.

Das Programm [Async02.kt] implementiert denselben TCP-Client mit beiden Extremmodellen: zuerst mit den Callback-Methoden von NIO.2, dann mit einer Coroutine. Es enthält außerdem einen kleinen Server, der von einem Thread ausgeführt wird und zwei Clients beantwortet (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) und dann mit einer Coroutine
package async02

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.suspendCancellableCoroutine
import java.io.IOException
import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.ServerSocket
import java.net.SocketAddress
import java.nio.ByteBuffer
import java.nio.channels.AsynchronousSocketChannel
import java.nio.channels.CompletionHandler
import java.util.concurrent.CountDownLatch
import kotlin.concurrent.thread
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException

const val PORT = 27500
val local: InetAddress = InetAddress.getLoopbackAddress()

fun main() {
    // ein minimaler Server, von einem Thread ausgeführt: er bedient zwei Clients und endet dann
    val listener = ServerSocket(PORT, 10, local)
    val server = thread(name = "server") {
        listener.use {
            for (i in 1..2) {
                listener.accept().use { service ->
                    // der Server lässt sich Zeit mit der Antwort
                    Thread.sleep(500)
                    service.getOutputStream().write("Hello client no. $i".toByteArray())
                }
            }
        }
    }
    display("start of the program")

    // 1 - der Stil "Callback-Methoden": AsynchronousSocketChannel und CompletionHandler
    val end = CountDownLatch(1)
    val client = AsynchronousSocketChannel.open()
    val buffer = ByteBuffer.allocate(1024)
    // die Verbindung wird gestartet, wobei das Objekt angegeben wird, das nach Abschluss aufgerufen wird
    client.connect(InetSocketAddress(local, PORT), Unit, object : CompletionHandler<Void?, Unit> {
        // Callback-Methode Nr. 1: die Verbindung steht
        override fun completed(nothing: Void?, attachment: Unit) {
            display("callbacks: connected, read started")
            // das Lesen der Antwort wird mit einem zweiten Callback-Objekt gestartet
            client.read(buffer, Unit, object : CompletionHandler<Int, Unit> {
                // Callback-Methode Nr. 2: Daten sind eingetroffen
                override fun completed(nbBytes: Int, attachment: Unit) {
                    display("callbacks: received [${String(buffer.array(), 0, nbBytes)}]")
                    client.close()
                    // der Hauptthread wird benachrichtigt
                    end.countDown()
                }

                override fun failed(e: Throwable, attachment: Unit) {
                    display("callbacks: read failed: $e")
                    end.countDown()
                }
            })
        }

        override fun failed(e: Throwable, attachment: Unit) {
            display("callbacks: connection failed: $e")
            end.countDown()
        }
    })
    display("callbacks: connection started, the program continues")
    // der Hauptthread hat nichts mehr zu tun: er wartet auf das Signal der letzten Callback-Methode
    end.await()

    // 2 - derselbe Client, geschrieben mit einer Coroutine: der Code liest sich von oben nach unten
    runBlocking {
        try {
            AsynchronousSocketChannel.open().use { channel ->
                // zwei suspendierende Funktionen: die Coroutine wird ausgesetzt, kein Thread wartet
                channel.connectTo(InetSocketAddress(local, PORT))
                display("coroutine: connected, read started")
                val buffer2 = ByteBuffer.allocate(1024)
                val nbBytes = channel.readInto(buffer2)
                display("coroutine: received [${String(buffer2.array(), 0, nbBytes)}]")
            }
        } catch (e: IOException) {
            display("coroutine: $e")
        }
    }
    server.join()
}

// die Verbindung mit Callback, umgewandelt in eine suspendierende Funktion
suspend fun AsynchronousSocketChannel.connectTo(address: SocketAddress): Unit =
    suspendCancellableCoroutine { continuation ->
        connect(address, Unit, object : CompletionHandler<Void?, Unit> {
            // die Callback-Methode setzt die ausgesetzte Coroutine fort…
            override fun completed(nothing: Void?, attachment: Unit) = continuation.resume(Unit)

            // … oder setzt sie fort, indem sie die Exception werfen lässt
            override fun failed(e: Throwable, attachment: Unit) = continuation.resumeWithException(e)
        })
    }

// das Lesen mit Callback, umgewandelt in eine suspendierende Funktion, die die Anzahl der gelesenen Bytes zurückgibt
suspend fun AsynchronousSocketChannel.readInto(buffer: ByteBuffer): Int =
    suspendCancellableCoroutine { continuation ->
        read(buffer, Unit, object : CompletionHandler<Int, Unit> {
            override fun completed(nbBytes: Int, attachment: Unit) = continuation.resume(nbBytes)
            override fun failed(e: Throwable, attachment: Unit) = continuation.resumeWithException(e)
        })
    }

// Anzeige mit vorangestelltem Namen des Threads, der sie ausführt
fun display(message: String) = println("[${Thread.currentThread().name}] $message")

Ergebnisse:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=async02.Async02Kt
[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]
[main] coroutine: connected, read started
[main] coroutine: received [Hello client no. 2]

Kommentare:

  • Zeilen 23–36: 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, der von der Funktion [thread] mit dem benannten Argument [name] erzeugt wird. Die Funktionen [use] schließen den [ServerSocket] und jeden bedienten [Socket] am Ende ihres Blocks;
  • Zeilen 38–71: Der Client ist mit Callback-Methoden geschrieben:
    • Zeile 40: Ein [AsynchronousSocketChannel] ist ein TCP-Kanal, dessen Operationen asynchron sind;
    • Zeile 43: [connect] startet die Verbindung und gibt die Kontrolle sofort zurück (Zeile 3 der Ergebnisse). Seine letzten beiden Parameter sind ein beliebiges Objekt, das die Callback-Methode erhält (hier [Unit], da wir es nicht brauchen), und das Callback-Objekt, das die Schnittstelle [CompletionHandler<V, A>] implementiert, wobei [V] der Typ des Ergebnisses der Operation ist ([Void?] bei einer Verbindung, die nichts zurückgibt) und [A] der Typ des übergebenen Objekts. Kotlin erlaubt es, dieses Objekt mit einem Objektausdruck ([object : CompletionHandler<Void?, Unit> { … }]) an Ort und Stelle zu erzeugen, was den anonymen Klassen von Java entspricht. Seine Methode [completed] wird aufgerufen, wenn die Operation erfolgreich ist, und seine Methode [failed] , wenn sie fehlschlägt;
    • Zeilen 44–48: Nach dem Verbindungsaufbau wird das Lesen mit *[read]* gestartet, wobei ein zweites Callback-Objekt angegeben wird, das im ersten verschachtelt ist;
    • Zeilen 49–54: Das Callback-Objekt für das Lesen erhält die Anzahl der gelesenen Bytes, zeigt die Nachricht an, schließt den Kanal und gibt den Hauptthread frei;
    • Zeile 71: Der Hauptthread hat nichts mehr zu tun. Damit das Programm nicht vor dem Ende des Austauschs beendet wird, wartet er auf ein Signal der letzten Callback-Methode: ein *[CountDownLatch] , der mit 1 initialisiert ist und dessen Methode *[await]* den aufrufenden Thread blockiert, bis ein anderer Thread seine Methode *[countDown] aufruft;
  • Die Ergebnisse zeigen, dass die Callback-Methoden von anderen Threads als dem Hauptthread ausgeführt werden (Threads aus dem JVM-Pool für asynchrone Kanäle, benannt [InnocuousThread-N]). Die Verschachtelung der beiden Callback-Objekte macht den Code bereits schwer nachvollziehbar; bei drei oder vier aufeinanderfolgenden Operationen landet man bei der sogenannten „Callback-Hölle“;
  • Zeilen 73–88: derselbe Client, geschrieben mit einer Coroutine, die von [runBlocking] gestartet wird. Der Code liest sich von oben nach unten wie synchroner Code: verbinden, lesen, anzeigen. Die Variablen sind gewöhnliche lokale Variablen; Fehler werden von einem einzigen [try / catch] behandelt; es gibt weder verschachtelte Callback-Objekte noch Signale zu verwalten. Dennoch wartet kein Thread auf die Verbindung oder die Antwort des Servers: [connectTo] und [readInto] sind Suspend-Funktionen, die die Coroutine während der Operation suspendieren;
  • Zeilen 92–99: Die Funktion [connectTo] wandelt die Callback-Operation in eine Suspend-Funktion um. Es ist eine Erweiterungsfunktion (Kapitel 4) von [AsynchronousSocketChannel], gekennzeichnet mit [suspend]. Die Funktion [suspendCancellableCoroutine] aus kotlinx.coroutines suspendiert die Coroutine, die sie aufruft, und übergibt dem Block die Continuation dieser Coroutine – also das Objekt, mit dem sie fortgesetzt werden kann. Der Block startet die Operation mit einem Callback-Objekt, das am Ende der Operation die Coroutine fortsetzt: entweder indem es einen Wert zurückgibt ([resume]) oder indem es sie eine Ausnahme auslösen lässt ([resumeWithException]). Die Callback-Methode tut nichts weiter: Die gesamte Logik des Clients bleibt in der Coroutine;
  • Zeilen 104–107: die Leseoperation, ebenfalls in eine Suspend-Funktion umgewandelt, die die Anzahl der gelesenen Bytes zurückgibt;
  • Das Ende der Ergebnisse zeigt, dass die Coroutine sowohl vor als auch nach den beiden Suspendierungen im Thread [main] ausgibt: Die Callback-Methode, die von einem [InnocuousThread] ausgeführt wird, setzt die Continuation fort, diese wird aber an den Thread [runBlocking] weitergeleitet. Im Abschnitt über Dispatcher werden wir sehen, wie der Thread gewählt wird, der den Rest einer Coroutine ausführt.

Es ist wichtig, diesen Mechanismus zu verstehen, da er für alle Coroutinen gilt: Eine suspendierte Coroutine ist eine ausstehende Continuation, und eine Continuation ist nichts weiter als eine Callback-Methode – aber eine, die der Compiler selbst aus dem restlichen Code erzeugt. Nur selten muss man Funktionen wie [connectTo] selbst schreiben: Die Bibliothek kotlinx.coroutines und andere Kotlin-Bibliotheken stellen für die meisten Operationen Suspend-Funktionen bereit. Muss man jedoch eine API verwenden, die nur Callback-Methoden anbietet, [suspendCancellableCoroutine] erlaubt es, sie in wenigen Zeilen umzuwandeln.

9.2. Künftige Ergebnisse: CompletableFuture und Deferred

9.2.1. CompletableFuture aus Sicht von Kotlin

Ein [Future<T>] (Schnittstelle des Pakets [java.util.concurrent], Java 5) ist ein Objekt, das das Ergebnis – vom Typ [T] – einer laufenden oder abgeschlossenen Operation repräsentiert. Wir sind ihm im vorigen Kapitel begegnet: Das gibt die Methode [submit] eines Executors zurück. Man kann es abfragen (ist es beendet? war es erfolgreich?), abbrechen ([cancel]) und auf sein Ergebnis warten ([get]), aber sonst nichts: 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 Funktionen hinzu:

  • man kann sie selbst beenden, entweder mit einem Ergebnis ([complete]) oder mit einer Ausnahme ([completeExceptionally]);
  • man kann ihr einen Folgeverarbeitungsschritt anhängen – eine Funktion, die ausgeführt wird, sobald das Ergebnis vorliegt ([thenApply], [thenAccept], [thenCompose] …) und die ein neues [CompletableFuture] erzeugt. So lassen sich Ketten von Operationen bilden, ohne dass Threads warten müssen.

Ein [CompletableFuture] ist kein Thread. Er kann einen Vorgang repräsentieren, der von einem Thread eines Executors ausgeführt wird (wie bei den mit [supplyAsync] erzeugten), aber viele werden von keinem Thread ausgeführt: Der von der Methode [sendAsync] des HTTP-Clients des JDK zurückgegebene wird abgeschlossen, wenn die Antwort des Servers eintrifft. Er ist ein Versprechen auf ein Ergebnis.

Kotlin-Programmierer begegnen [CompletableFuture] jedes Mal, wenn sie eine asynchrone Java-Bibliothek verwenden: den HTTP-Client des JDK, bestimmte Datenbanktreiber, Clients für Cloud-Dienste und so weiter. Sie müssen damit umgehen können – und vor allem wissen, wie man sie mit Coroutinen verbindet. Das Programm [Async03.kt] ist eine Kotlin-Version des Java-Programms, das die wichtigsten Wege zum Erzeugen, Abfragen und Abwarten eines [CompletableFuture] zeigte:

// CompletableFutures aus Sicht von Kotlin: Erstellung, Warten, Zustand, Ergebnis, Fortsetzung
package async03

import java.util.concurrent.CompletableFuture
import java.util.concurrent.CompletionException
import java.util.concurrent.ExecutionException
import java.util.concurrent.TimeUnit

fun main() {
    // 1 - supplyAsync übergibt eine Verarbeitung an einen Executor und gibt ein CompletableFuture<T> zurück
    val f1: CompletableFuture<Long> = CompletableFuture.supplyAsync {
        // eine Berechnung von einigen Zehntelsekunden
        var sum = 0L
        for (i in 1..200_000_000) {
            sum += i % 7
        }
        sum
    }
    println("f1 started, state: ${f1.state()}")
    // join() wartet auf das Ende der Verarbeitung, blockiert den aktuellen Thread und gibt ihr Ergebnis zurück
    val result = f1.join()
    println("f1 finished, state: ${f1.state()}, result: $result")

    // 2 - ein CompletableFuture, das nach 300 ms von einem Timer abgeschlossen wird, ohne einen Thread zu belegen
    val f2 = CompletableFuture<Unit>().completeOnTimeout(Unit, 300, TimeUnit.MILLISECONDS)
    println("f2 started, state: ${f2.state()}")
    f2.join()
    println("f2 finished, state: ${f2.state()}")

    // 3 - bereits abgeschlossene CompletableFutures, erfolgreich oder mit Fehler
    val f3 = CompletableFuture.completedFuture(42)
    val f4 = CompletableFuture.failedFuture<Int>(IllegalStateException("breakdown"))
    println("f3: state ${f3.state()}, result ${f3.resultNow()} ; " +
            "f4: state ${f4.state()}, exception ${f4.exceptionNow()}")

    // 4 - eine Verarbeitung, die fehlschlägt: join() wirft eine CompletionException, die ihre Exception verpackt
    val f5 = CompletableFuture.supplyAsync { "abc".toInt() }
    try {
        f5.join()
    } catch (e: CompletionException) {
        println("f5: state ${f5.state()}, join() throws ${e.javaClass.simpleName} containing ${e.cause}")
    }

    // 5 - get(), vom Interface Future geerbt, verpackt die Exception in eine ExecutionException
    try {
        f5.get()
    } catch (e: ExecutionException) {
        println("f5: get() throws ${e.javaClass.simpleName} containing ${e.cause?.javaClass?.simpleName}")
    }

    // 6 - eine Continuation: was zu tun ist, wenn das CompletableFuture abgeschlossen ist
    val f6: CompletableFuture<Int> = f2.thenApply { 2 * 21 }
    val f7: CompletableFuture<Void> = f6.thenAccept { value ->
        println("f7: the continuation received $value")
    }
    f7.join()

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

Ergebnisse:

> gradlew -q run -Pmain=async03.Async03Kt
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: breakdown
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

Kommentare:

  • Zeilen 10–17: [CompletableFuture.supplyAsync(supplier)] übergibt eine Funktion ohne Parameter (einen Java-[Supplier<T>]) an einen Executor und gibt sofort ein [CompletableFuture<T>] zurück, das dessen Ausführung repräsentiert. Dank der SAM-Konvertierung (Kapitel 7) wird ihm ein Kotlin-Lambda übergeben, das außerhalb der Klammern steht; sein letzter Ausdruck [sum] ist das Ergebnis. Ohne expliziten Executor führt der gemeinsame Pool der JVM, [ForkJoinPool.commonPool()], die Funktion aus;
  • Zeile 19: Die Methode [state()] (Java 19) gibt den Status der Operation zurück: [RUNNING] (läuft), [SUCCESS] (erfolgreich abgeschlossen), [FAILED] (mit einer Ausnahme abgeschlossen) oder [CANCELLED] (abgebrochen). Dies sind die Konstanten der Aufzählung [Future.State];
  • Zeile 21: [join()] wartet, bis die Operation beendet ist, und gibt ihr Ergebnis zurück. Das ist ein blockierendes Warten: Der aktuelle Thread (hier der Hauptthread, was ein kleines Konsolenprogramm nicht stört) wird angehalten;
  • Zeilen 24–28: ein [CompletableFuture] , der über seinen Konstruktor „laufend“ erzeugt und nach 300 ms von einem Timer beendet wird ([completeOnTimeout], Java 9): Das ist das asynchrone Äquivalent zu [Thread.sleep(300)]. In Java hat eine Operation ohne Ergebnis den Typ [CompletableFuture<Void>]; in Kotlin kann man [CompletableFuture<Unit>] schreiben, dessen einziger Wert [Unit] ist;
  • Zeilen 30–34: [completedFuture(42)] gibt einen bereits abgeschlossenen [CompletableFuture] mit dem Ergebnis 42 zurück, und [failedFuture(exception)] gibt einen [CompletableFuture] zurück, der bereits fehlgeschlagen ist; der Ergebnistyp des Letzteren lässt sich nicht aus seinem Argument ableiten und wird daher zwischen spitzen Klammern angegeben: [failedFuture<Int>(...)]. [resultNow()] und [exceptionNow()] (Java 19) geben das Ergebnis oder die Ausnahme einer abgeschlossenen Operation sofort zurück, ohne zu warten;
  • Zeilen 36–41: Eine Operation, deren Funktion eine Ausnahme auslöst, endet im Zustand [FAILED]. Die Ausnahme wird im [CompletableFuture] gespeichert, und [join()] löst eine [CompletionException] aus, deren Ursache ([cause], die als Eigenschaft behandelte Methode [getCause()]) die ursprüngliche Ausnahme ist – hier eine [NumberFormatException] , ausgelöst durch ["abc".toInt()];
  • Zeilen 44–48: [get()], die von der Schnittstelle [Future] geerbte Methode, wartet ebenfalls blockierend, verpackt die Ausnahme aber in eine [ExecutionException]. In Java ist dies eine geprüfte Ausnahme, die die Methode [main] abfangen oder deklarieren musste, ebenso wie die [InterruptedException], die [get()] auslösen kann. Kotlin kennt keine geprüften Ausnahmen: Man fängt nur die ab, die einen interessieren, und sonst nichts;
  • Zeilen 51–56: eine Continuation. [f2.thenApply { 2 * 21 }] gibt einen neuen [CompletableFuture] zurück, der mit dem Ergebnis der Funktion abgeschlossen wird, sobald [f2] abgeschlossen ist: Das ergibt einen [CompletableFuture<Int>]. [thenAccept] hängt eine Funktion an, die das Ergebnis verbraucht, ohne eines zu erzeugen, und gibt einen [CompletableFuture<Void>] zurück (das ist eine Java-Methode: Ihr Rückgabetyp ist [Void], den Kotlin nicht in [Unit] umwandelt);
  • Zeilen 58–60: die booleschen Methoden [isDone()] (abgeschlossen, gleichgültig wie), [isCompletedExceptionally()] (mit einer Ausnahme abgeschlossen oder abgebrochen) und [isCancelled()] (abgebrochen): Kotlin stellt sie als Eigenschaften dar: [isDone], [isCompletedExceptionally] und [isCancelled].

Der Java-Kurs widmete anschließend mehrere Seiten der Komposition von [CompletableFuture]: [thenCompose], [thenCombine], [allOf], [anyOf], [exceptionally], [handle], [orTimeout] … In Kotlin braucht man diese Methoden fast nie: Man muss lediglich in einer Coroutine mit der Suspend-Funktion auf den [CompletableFuture] warten, und zwar mit [await()], und den Rest wie gewöhnlichen Code schreiben. Die folgende Tabelle vergleicht die Methoden von [CompletableFuture] mit ihren Entsprechungen bei Coroutinen (alle diese Funktionen werden in diesem Kapitel behandelt):

[CompletableFuture]
Coroutinen
[supplyAsync(f)], [runAsync(r)]
[async { … }] (gibt ein [Deferred<T>] zurück), [launch { … }] (gibt einen [Job] zurück)
[completedFuture(v)], [complete(v)]
ein einzelner Wert; [CompletableDeferred] zum manuellen Abschließen einer Operation
[thenApply(f)], [thenAccept(c)], [thenRun(r)]
[val v = operation()] gefolgt vom restlichen Code
[thenCompose(f)]
zwei aufeinanderfolgende Aufrufe von Suspend-Funktionen
[thenCombine(other, f)], [allOf(...)]
[async], gefolgt von [await] und [awaitAll]
[anyOf(...)]
[select]
[exceptionally(f)], [handle(f)], [whenComplete(c)]
[try / catch / finally]
[orTimeout(...)], [completeOnTimeout(...)]
[withTimeout], [withTimeoutOrNull]
[cancel]
[cancel], das die Operation tatsächlich beendet (kooperativer Abbruch)
[join()], [get()]
[await()], [join()]: Wartevorgänge, die die Coroutine suspendieren, statt den Thread zu blockieren

9.2.2. Deferreds

Das Coroutinen-Äquivalent eines [CompletableFuture<T>] ist die Schnittstelle [Deferred<T>] („deferred“, „aufgeschoben“) von kotlinx.coroutines: das künftige Ergebnis einer Coroutine. Man erhält es, indem man eine Coroutine mit der Funktion [async] startet und mit der Suspend-Funktion [await()] auf ihr Ergebnis wartet. Ein [Deferred<T>] ist ein Spezialfall von [Job], der Schnittstelle, die eine gerade laufende oder beendete Coroutine ohne Ergebnis repräsentiert; einen *[Job]* erhält man, indem man eine Coroutine mit der Funktion *[launch]* startet und mit der Suspend-Funktion *[join()]* auf ihr Ende wartet.

Das Programm [Async04.kt] zeigt das [Deferred], den [Job] und den Übergang vom Ersteren zum [CompletableFuture] und umgekehrt:

// Deferreds: das zukünftige Ergebnis einer Coroutine; Übergang von Deferred zu CompletableFuture
package async04

import kotlinx.coroutines.Deferred
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.future.asCompletableFuture
import kotlinx.coroutines.future.await
import kotlinx.coroutines.future.future
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.supervisorScope
import java.util.concurrent.CompletableFuture

fun main() = runBlocking {
    // 1 - async startet eine Coroutine und gibt sofort ein Deferred<T> zurück
    val d1: Deferred<Long> = async(Dispatchers.Default) {
        // dieselbe Berechnung von einigen Zehntelsekunden
        var sum = 0L
        for (i in 1..200_000_000) {
            sum += i % 7
        }
        sum
    }
    println("d1 started: ${state(d1)}")
    // await() setzt die aktuelle Coroutine bis zum Ergebnis aus, ohne ihren Thread zu blockieren
    val result = d1.await()
    println("d1 finished: ${state(d1)}, result: $result")

    // 2 - eine Coroutine, die 300 ms "wartet": delay setzt sie aus, kein Thread wird belegt
    val d2: Deferred<String> = async {
        delay(300)
        "end of the delay"
    }
    println("d2 started: ${state(d2)}")
    println("d2 finished: ${d2.await()}")

    // 3 - launch startet eine Coroutine ohne Ergebnis und gibt einen Job zurück; join() wartet auf ihr Ende
    val job: Job = launch {
        delay(100)
        println("job: work finished")
    }
    job.join()
    println("job: ${state(job)}")

    // 4 - eine Verarbeitung, die fehlschlägt: await() wirft die ursprüngliche Exception erneut, ohne Wrapper
    // (supervisorScope verhindert, dass sich der Fehler auf das Programm ausbreitet: siehe den Abschnitt über Exceptions)
    supervisorScope {
        val d4 = async { "abc".toInt() }
        try {
            d4.await()
        } catch (e: NumberFormatException) {
            println("d4: ${state(d4)}, await() throws ${e.javaClass.simpleName} : ${e.message}")
        }
    }

    // 5 - auf ein CompletableFuture kann eine Coroutine warten: await() setzt aus, ohne zu blockieren
    val f5: CompletableFuture<Int> = CompletableFuture.supplyAsync { 6 * 7 }
    println("f5: CompletableFuture awaited by a coroutine: ${f5.await()}")

    // 6 - und ein Deferred kann als CompletableFuture präsentiert werden, zum Beispiel für Java-Code
    val f6: CompletableFuture<Long> = d1.asCompletableFuture()
    println("f6: Deferred seen as a CompletableFuture: state ${f6.state()}, result ${f6.resultNow()}")
    // future { } startet eine Coroutine und gibt direkt ein CompletableFuture zurück
    val f7: CompletableFuture<String> = future {
        delay(100)
        "result of a coroutine"
    }
    println("f7: ${f7.thenApply { it.uppercase() }.await()}")
}

// der Zustand eines Jobs (ein Deferred ist ein Job, der ein Ergebnis trägt)
fun state(job: Job) = "isActive=${job.isActive}, isCompleted=${job.isCompleted}, isCancelled=${job.isCancelled}"

Ergebnisse:

> gradlew -q run -Pmain=async04.Async04Kt
d1 started: isActive=true, isCompleted=false, isCancelled=false
d1 finished: isActive=false, isCompleted=true, isCancelled=false, result: 599999998
d2 started: isActive=true, isCompleted=false, isCancelled=false
d2 finished: end of the delay
job: work finished
job: isActive=false, isCompleted=true, isCancelled=false
d4: isActive=false, isCompleted=true, isCancelled=true, await() throws NumberFormatException : For input string: "abc"
f5: CompletableFuture awaited by a coroutine: 42
f6: Deferred seen as a CompletableFuture: state SUCCESS, result 599999998
f7: RESULT OF A COROUTINE

Kommentare:

  • Zeile 17: Die Funktion [main] ist ein Ausdruck [runBlocking { … }]. Der Block wird als Coroutine vom Thread [main] ausgeführt, und [runBlocking] gibt die Kontrolle erst am Ende dieser Coroutine zurück. Innerhalb dieses Blocks können Suspend-Funktionen ([await], [delay] …) aufgerufen und weitere Coroutinen ([async], [launch]) gestartet werden: Der Block erhält implizit einen [CoroutineScope] (einen Coroutine-Scope), dessen Erweiterungsfunktionen [async] und [launch] sind. Wir kommen im Abschnitt über strukturierte Nebenläufigkeit darauf zurück;
  • Zeilen 18–25: [async] startet eine neue Coroutine, die den Block ausführt, und gibt sofort ein [Deferred<Long>] zurück, das ihr Ergebnis repräsentiert (der letzte Ausdruck des Blocks). Der Parameter [Dispatchers.Default] bewirkt, dass die Coroutine von einem Thread-Pool ausgeführt wird, der für Berechnungen vorgesehen ist: Ohne ihn würde die Coroutine vom Thread von [runBlocking] ausgeführt und erst starten, wenn die Haupt-Coroutine zum ersten Mal suspendiert wird;
  • Zeile 27: Der Zustand einer Coroutine wird durch drei Eigenschaften von [Job] bestimmt: [isActive] (läuft), [isCompleted] (abgeschlossen, gleichgültig wie) und [isCancelled] (abgebrochen oder fehlgeschlagen, wie wir später sehen werden). Die Funktion [state] (Zeilen 74–75) zeigt sie an;
  • Zeile 29: [await()] wartet, bis die Coroutine beendet ist, und gibt ihr Ergebnis zurück. Anders als [join()] bei einem [CompletableFuture] blockiert dieses Warten den Thread nicht: Es ist eine Suspend-Funktion, die die Haupt-Coroutine suspendiert; währenddessen steht der Thread [main] für andere Coroutinen zur Verfügung;
  • Zeilen 32–38: eine Coroutine, die mit *[delay]* 300 ms wartet und dann einen String zurückgibt: Während des Wartens ist kein Thread belegt;
  • Zeilen 40–46: [launch] startet eine Coroutine, die kein Ergebnis zurückgibt, und gibt einen [Job] zurück. [join()] suspendiert die Haupt-Coroutine, bis diese Coroutine beendet ist. [launch] / [Job] sind für Coroutinen das, was [runAsync] / [CompletableFuture<Void>] in der Welt von [CompletableFuture] sind;
  • Zeilen 48–55: eine Coroutine, die fehlschlägt. [await()] löst die ursprüngliche Ausnahme erneut aus, eine [NumberFormatException], ohne sie in eine andere Ausnahme zu verpacken: Sie wird abgefangen, als wäre der Aufruf direkt erfolgt. Der angezeigte Zustand zeigt, dass ein fehlgeschlagener [Job] hat die Eigenschaft [isCancelled=true]: Für kotlinx.coroutines ist ein Fehlschlag eine Form von Abbruch. Der Block [supervisorScope] ist hier aus einem Grund erforderlich, den wir im Abschnitt über Ausnahmen sehen werden: Ohne ihn würde sich der Fehlschlag einer Coroutine auf die Coroutine übertragen, die sie gestartet hat, und das gesamte Programm beenden;
  • Zeilen 59–61: Die Erweiterungsfunktion [CompletableFuture<T>.await()] aus dem Paket [kotlinx.coroutines.future] wartet auf einen [CompletableFuture] , indem sie die Coroutine suspendiert, ohne Threads zu blockieren. Sie dient als Brücke zwischen asynchronen Java-Bibliotheken und Coroutinen: Ein Aufruf [client.sendAsync(request, handler).await()] wartet auf die Antwort eines Webservers, wie wir später in diesem Kapitel sehen werden. Wenn der [CompletableFuture] fehlschlägt, löst [await()] die ursprüngliche Ausnahme aus, befreit von ihrer [CompletionException]-Hülle;
  • Zeilen 63–65: Umgekehrt stellt [asCompletableFuture()] ein [Deferred] als [CompletableFuture] dar, zum Beispiel um es an Java-Code zu übergeben, der Coroutinen nicht unterstützt;
  • Zeilen 66–71: Die Funktion [future { … }] startet eine Coroutine und gibt direkt einen [CompletableFuture] zurück: So schreibt man in Kotlin mithilfe von Coroutinen eine asynchrone Methode, die für Java-Code gedacht ist. In Zeile 71 wird dieser *[CompletableFuture] mit *[thenApply] komponiert, und anschließend wird das Ergebnis mit *[await()]* abgewartet.

9.3. Suspend-Funktionen

9.3.1. suspend, launch, async und await

In Kotlin wird eine asynchrone Operation als Suspend-Funktion geschrieben: eine gewöhnliche Funktion, die mit dem Modifizierer *[suspend] deklariert ist und ihr Ergebnis direkt zurückgibt (statt eines *[CompletableFuture] oder *[Deferred]*, der es repräsentieren würde):

  • [suspend fun makeCoffee()] für eine Operation, die kein Ergebnis zurückgibt;
  • [suspend fun countSugars(number: Int): Int] für eine Operation, die eine ganze Zahl zurückgibt.

Eine Suspend-Funktion kann andere Suspend-Funktionen aufrufen, etwa [delay], [await] und [join], und bei diesen Aufrufen kann sie suspendiert werden. Sie kann nur von einer anderen Suspend-Funktion oder aus einer Coroutine heraus aufgerufen werden (dem Rumpf eines [runBlocking], eines [launch] oder eines [async]); der Compiler erzwingt dies. Das ist die einzige Einschränkung: Im Inneren schreibt man gewöhnlichen Code, mit Schleifen, [if], [try / catch] und lokalen Variablen.

Ein Aufruf einer Suspend-Funktion enthält keine Schlüsselwörter: Wo C# [await MakeCoffeeAsync()] schreibt, schreibt Kotlin [makeCoffee()]. Und dieser Aufruf ist sequenziell: Die nächste Zeile wird erst ausgeführt, nachdem die aufgerufene Funktion beendet ist. Um mehrere Operationen parallel auszuführen, muss man dies ausdrücklich angeben, indem man neue Coroutinen mit [launch] oder *[async]* startet. Das ist eine bewusste Entscheidung der Kotlin-Entwickler: Sequenzieller Code ist der Normalfall und sollte daher am einfachsten zu schreiben sein; Nebenläufigkeit sollte explizit sein.

Das Java-Tutorial kochte Kaffee und zählte Zuckerwürfel, zunächst mit [CompletableFuture] , verkettet mit [thenRun] und [thenCompose], dann mit blockierendem Code, der von virtuellen Threads ausgeführt wird. Das Programm [Async05.kt] kocht denselben Kaffee mit Suspend-Funktionen:

// Kaffee mit suspendierenden Funktionen: gewöhnliche Funktionen, die sich von oben nach unten lesen
package async05

import kotlinx.coroutines.Deferred
import kotlinx.coroutines.Job
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

var start = System.nanoTime()

fun main() = runBlocking {
    // 1 - die beiden Operationen werden in zwei Coroutinen gestartet und dann abgewartet
    display("launching makeCoffee")
    val preparation: Job = launch { makeCoffee() }
    display("makeCoffee is launched: the program continues")
    display("launching countSugars")
    val counting: Deferred<Int> = async { countSugars(3) }
    display("countSugars is launched")
    // wir warten nun auf die beiden Operationen: die Haupt-Coroutine wird ausgesetzt
    preparation.join()
    val nbSugars = counting.await()
    display("coffee ready, with $nbSugars sugar(s)")

    // 2 - dieselben direkt aufgerufenen Funktionen: sie laufen nacheinander
    start = System.nanoTime()
    display("direct calls")
    makeCoffee()
    val number = countSugars(3)
    display("coffee ready, with $number sugar(s)")
}

// eine suspendierende Funktion, die kein Ergebnis zurückgibt
suspend fun makeCoffee() {
    display("  coffee: the machine is heating up")
    // delay setzt die Coroutine aus, ohne den ausführenden Thread zu blockieren
    delay(1000)
    display("  coffee: the machine is pouring the coffee")
    delay(500)
    display("  coffee: finished")
}

// eine suspendierende Funktion, die eine ganze Zahl zurückgibt
suspend fun countSugars(number: Int): Int {
    for (i in 1..number) {
        delay(200)
        display("  sugar no. $i")
    }
    return number
}

// Anzeige mit der seit [start] verstrichenen Zeit und dem Namen des Threads
fun display(message: String) {
    val elapsed = (System.nanoTime() - start) / 1_000_000
    println("%5d ms [%s] %s".format(elapsed, Thread.currentThread().name, message))
}

Ergebnisse:

> gradlew -q run -Pmain=async05.Async05Kt
   47 ms [main] launching makeCoffee
   62 ms [main] makeCoffee is launched: the program continues
   62 ms [main] launching countSugars
   65 ms [main] countSugars is launched
   67 ms [main]   coffee: the machine is heating up
  281 ms [main]   sugar no. 1
  482 ms [main]   sugar no. 2
  683 ms [main]   sugar no. 3
 1068 ms [main]   coffee: the machine is pouring the coffee
 1569 ms [main]   coffee: finished
 1571 ms [main] coffee ready, with 3 sugar(s)
    0 ms [main] direct calls
    0 ms [main]   coffee: the machine is heating up
 1000 ms [main]   coffee: the machine is pouring the coffee
 1501 ms [main]   coffee: finished
 1702 ms [main]   sugar no. 1
 1902 ms [main]   sugar no. 2
 2103 ms [main]   sugar no. 3
 2104 ms [main] coffee ready, with 3 sugar(s)

Kommentare:

  • Zeilen 34–41: Eine Scheinoperation, geschrieben als gewöhnliche Funktion: eine Ausgabe, ein Warten von einer Sekunde, eine Ausgabe, ein Warten von einer halben Sekunde, eine Ausgabe. [delay] ist die Suspend-Funktion von kotlinx.coroutines, die die angegebene Zeit wartet (in Millisekunden oder in Form einer Dauer [kotlin.time.Duration]: [delay(1.seconds)]), indem sie die Coroutine suspendiert. Das entspricht der Methode [delay] im Java-Programm, die einen von einem Timer beendeten [CompletableFuture] zurückgab; hier muss der Rest der Funktion jedoch nicht in einer Continuation geschrieben werden: Er folgt einfach auf den Aufruf;
  • Zeilen 44–50: eine Operation, die eine ganze Zahl zurückgibt. Die Schleife ist eine echte Schleife, die bei jeder Iteration wartet: Das ist der einzige Unterschied zur Java-Version mit [CompletableFuture], in der die Schleife eine Kette von [thenCompose] aufbaute, statt Iterationen auszuführen (und in der für das Lambda eine Variable [number] – eine Kopie von [i] – nötig war);
  • Zeile 16: [launch] startet eine neue Coroutine, die [makeCoffee()] ausführt, und gibt sofort einen [Job] zurück;
  • Zeile 19: [async] startet eine neue Coroutine, die [countSugars(3)] ausführt, und gibt sofort ein [Deferred<Int>] zurück;
  • Zeilen 22–23: Die Haupt-Coroutine wartet auf beide Operationen; während dieser Wartezeiten ist sie suspendiert;
  • Die Zeilen 2 bis 12 der Ausgabe zeigen den Ablauf: Der Kaffee ist nach 1,5 Sekunden fertig – der Dauer der längeren der beiden Operationen –, und die Zuckerstücke wurden gezählt, während die Maschine sich aufheizte. Sie zeigen aber auch einen Unterschied zu den Java-Programmen: Die Maschine beginnt erst mit dem Aufheizen (Zeile 6) nach der letzten Ausgabe des Hauptprogramms (Zeile 5). Alle Coroutinen des Programms werden von einem einzigen Thread ausgeführt, [main], der zu [runBlocking] gehört: [launch] und [async] führen die von ihnen erzeugte Coroutine nicht sofort aus; stattdessen stellen sie sie in die Warteschlange des Threads, der sie ausführt, sobald er frei wird – das heißt, wenn die Haupt-Coroutine sich suspendiert (Zeile 22). Das nennt man kooperatives Multitasking: Eine Coroutine hält den Thread, bis sie sich selbst suspendiert;
  • Zeilen 26–31: dieselben Funktionen, direkt aufgerufen, ohne eine Coroutine zu starten. Jeder Aufruf ist abgeschlossen, bevor der nächste beginnt: Der Kaffee wird gekocht (1,5 Sekunden), dann werden die Zuckerstücke gezählt (0,6 Sekunden), insgesamt also 2,1 Sekunden (Zeilen 13–20 der Ergebnisse). Das ist der richtige Ansatz, wenn eine Operation vom Ergebnis der vorherigen abhängt;
  • Zeile 54: Jede Ausgabe zeigt die verstrichene Zeit und den Thread, der sie ausführt: Es ist immer [main].

Wir sehen dieselbe Qualität wie in der Java-Version mit virtuellen Threads: Die Funktionen sind gewöhnliche Funktionen, die man von oben nach unten liest; ob sie sequenziell (direkter Aufruf) oder nebenläufig ([launch], [async]) ausgeführt werden, wird beim Aufruf entschieden. Anders als bei virtuellen Threads genügte jedoch ein einziger Thread für das gesamte Programm, und es war nicht die JVM, die den Thread während des Wartens freigab, sondern die Suspend-Funktionen selbst.

9.3.2. delay und Thread.sleep

Eine Coroutine gibt ihren Thread nur frei, wenn sie sich selbst suspendiert – das heißt, wenn sie eine wartende Suspend-Funktion aufruft. Ruft sie eine blockierende Funktion auf ([Thread.sleep], einen Datei- oder Socket-Lesevorgang mit den Klassen aus [java.io], eine JDBC-Anfrage …), blockiert sie den Thread, der sie ausführt, und alle Coroutinen, die auf diesen Thread angewiesen sind, werden angehalten. Das Programm [Async06.kt] veranschaulicht den Unterschied:

// delay setzt die Coroutine aus, Thread.sleep blockiert den Thread
package async06

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

var start = 0L

fun main() {
    // 1 - zwei Coroutinen, die mit delay warten: sie teilen sich den einzigen Thread [main]
    start = System.nanoTime()
    runBlocking {
        launch { workWithDelay("A") }
        launch { workWithDelay("B") }
    } // runBlocking kehrt zurück, wenn seine beiden Coroutinen beendet sind
    display("1 - end, with delay")

    // 2 - dieselben Coroutinen mit Thread.sleep: der Thread [main] ist bei jedem Warten blockiert
    start = System.nanoTime()
    runBlocking {
        launch { workWithSleep("A") }
        launch { workWithSleep("B") }
    }
    display("2 - end, with Thread.sleep")

    // 3 - Thread.sleep auf dem IO-Dispatcher: jede Coroutine blockiert einen Thread des IO-Pools
    start = System.nanoTime()
    runBlocking {
        launch(Dispatchers.IO) { workWithSleep("A") }
        launch(Dispatchers.IO) { workWithSleep("B") }
    }
    display("3 - end, with Thread.sleep on Dispatchers.IO")
}

// drei Schritte, getrennt durch Wartezeiten von 100 ms, die die Coroutine aussetzen
suspend fun workWithDelay(name: String) {
    for (i in 1..3) {
        display("  $name$i")
        delay(100)
    }
}

// drei Schritte, getrennt durch Wartezeiten von 100 ms, die den Thread blockieren
fun workWithSleep(name: String) {
    for (i in 1..3) {
        display("  $name$i")
        Thread.sleep(100)
    }
}

// Anzeige mit der seit [start] verstrichenen Zeit und dem Namen des Threads
fun display(message: String) {
    val elapsed = (System.nanoTime() - start) / 1_000_000
    println("%5d ms [%s] %s".format(elapsed, Thread.currentThread().name, message))
}

Ergebnisse:

> gradlew -q run -Pmain=async06.Async06Kt
   67 ms [main]   A1
   97 ms [main]   B1
  193 ms [main]   A2
  198 ms [main]   B2
  294 ms [main]   A3
  298 ms [main]   B3
  399 ms [main] 1 - end, with delay
    1 ms [main]   A1
  101 ms [main]   A2
  202 ms [main]   A3
  303 ms [main]   B1
  403 ms [main]   B2
  504 ms [main]   B3
  604 ms [main] 2 - end, with Thread.sleep
   10 ms [DefaultDispatcher-worker-1]   A1
   10 ms [DefaultDispatcher-worker-2]   B1
  112 ms [DefaultDispatcher-worker-1]   A2
  112 ms [DefaultDispatcher-worker-2]   B2
  213 ms [DefaultDispatcher-worker-1]   A3
  213 ms [DefaultDispatcher-worker-2]   B3
  314 ms [main] 3 - end, with Thread.sleep on Dispatchers.IO

Kommentare:

  • Zeilen 12–18: Zwei Coroutinen, die in einem *[runBlocking] gestartet werden und jeweils drei durch *[delay(100)]* getrennte Schritte ausführen. Sie teilen sich den Thread *[main] : Während die eine wartet, arbeitet die andere; die Schritte wechseln sich ab (A1, B1, A2, B2 …), und die Wartezeiten der beiden Coroutinen überlappen sich: Der gesamte Vorgang dauert etwa 300 ms, plus die Zeit zum Laden der Bibliotheksklassen bei dieser ersten Verwendung (Zeile 8 der Ergebnisse). Die Funktion [runBlocking] gibt die Kontrolle erst zurück, wenn die beiden von ihr gestarteten Coroutinen beendet sind: Es muss kein Code geschrieben werden, um auf sie zu warten;
  • Zeilen 20–26: dieselben Coroutinen, die mit [Thread.sleep] warten. Jedes Warten blockiert den einzigen Thread [main]: Coroutine B kann erst starten, wenn A beendet ist, und der gesamte Vorgang dauert 600 ms (Zeilen 9–15). Die beiden Coroutinen sind keine echten Coroutinen mehr: Sie laufen nacheinander ab;
  • Zeilen 28–34: Coroutinen, die blockierenden Code enthalten, werden an eine andere Gruppe von Threads übergeben, den Dispatcher [Dispatchers.IO], indem man ihn als Parameter an [launch] übergibt. Jede blockiert dann ihren eigenen Thread; sie laufen gleichzeitig, und der gesamte Vorgang dauert wieder 300 ms (Zeilen 16–22). Das ist der Standardansatz, wenn blockierender Code aus Coroutinen heraus aufgerufen werden muss (etwa eine Bibliothek, die keine Suspend-Funktionen anbietet, zum Beispiel JDBC); dies verursacht jedoch die Kosten eines Systemthreads pro laufender Operation. Die Threads dieses Dispatchers heißen [DefaultDispatcher-worker-N]: Warum, sehen wir im Abschnitt über Dispatcher;
  • Zeilen 37–41: [workWithDelay] ruft [delay] auf: Das ist eine Suspend-Funktion;
  • Zeilen 45–49: [workWithSleep] ruft keine Suspend-Funktion auf: Es ist eine gewöhnliche Funktion. Der Compiler erlaubt es, sie aus einer Coroutine aufzurufen, aber IntelliJ und IDEA markieren Aufrufe bekannter blockierender Funktionen ([Thread.sleep], die E/A-Operationen in [java.io]) innerhalb einer Suspend-Funktion oder einer Coroutine („Possibly blocking call in non-blocking context“).

Daraus ergibt sich die erste Regel der Programmierung mit Coroutinen: Eine Suspend-Funktion darf ihren Thread niemals blockieren. Muss sie blockierenden Code aufrufen, delegiert sie ihn an einen dafür vorgesehenen Dispatcher ([Dispatchers.IO], oder einen Dispatcher auf virtuellen Threads), und zwar mit [withContext], das wir in Kürze behandeln.

9.3.3. Was der Compiler tut: Continuations und Zustandsmaschinen

Wie kann eine Suspend-Funktion mitten in einer Schleife pausieren, ihren Thread freigeben und später an derselben Stelle mit denselben Werten der lokalen Variablen fortgesetzt werden, möglicherweise in einem anderen Thread? Der Java-Kurs hat erklärt, dass bei einem virtuellen Thread die JVM diese Arbeit leistet: Sie kopiert den Aufrufstack des virtuellen Threads auf den Heap und stellt ihn dort später wieder her. Die JVM weiß nichts von Kotlin-Coroutinen: Es ist der Compiler, der die Arbeit leistet, indem er jede Suspend-Funktion transformiert. Er tut dies in zwei Schritten.

Erster Schritt: Die Continuation wird zu einem Parameter. Jede [suspend]-Funktion erhält im Bytecode einen zusätzlichen Parameter vom Typ [Continuation<T>] (eine Schnittstelle aus dem Paket [kotlin.coroutines] der Standardbibliothek), wobei [T] der Typ des Rückgabewerts der Funktion ist. Eine Continuation repräsentiert „den nächsten Schritt der Berechnung“: was mit dem Ergebnis der Funktion geschehen soll. Sie hat eine Methode [resumeWith(result)], die die Ausführung mit einem Ergebnis oder einer Ausnahme fortsetzt (die Erweiterungsfunktionen [resume(value)] und [resumeWithException(e)] rufen sie auf), und eine Eigenschaft [context], den Coroutine-Kontext (darauf kommen wir zurück). Der Rückgabetyp der Funktion wird zu [Any?] ([Object] auf der JVM): Die Funktion gibt entweder ihr Ergebnis zurück, wenn sie ohne Warten abgeschlossen werden konnte, oder einen speziellen Wert, [COROUTINE_SUSPENDED], der bedeutet: „Ich bin suspendiert; meine Continuation wird später fortgesetzt.“ Das ist der „Continuation-Passing Style“ (CPS).

Zweiter Schritt: Der Funktionsrumpf wird zu einer Zustandsmaschine. Jeder Aufruf einer Suspend-Funktion im Rumpf ist ein möglicher Suspendierungspunkt. Der Compiler nummeriert diese Punkte (die Nummer heißt [label]) und speichert die Nummer des nächsten Fortsetzungspunkts sowie die lokalen Variablen, die eine Suspendierung überleben müssen, in einem für die Funktion spezifischen Continuation-Objekt. Der Funktionsrumpf wird zu einem [when] über diese Nummer: Er wird einmal am Anfang betreten (Label 0), danach einmal bei jeder Fortsetzung, und das Programm springt direkt zu der Stelle, an der es aufgehört hat.

Das Programm [Async07.kt] zeigt all dies. Es verwendet nur die Kotlin-Standardbibliothek (nicht kotlinx.coroutines), damit wir die grundlegenden Mechanismen sehen können: Es schreibt das Äquivalent von [delay] selbst und startet eine Coroutine eigenhändig.

// was der Compiler tut: eine suspendierende Funktion erhält eine Continuation
// (dieses Programm verwendet nur die Kotlin-Standardbibliothek, nicht kotlinx.coroutines)
package async07

import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import kotlin.coroutines.Continuation
import kotlin.coroutines.EmptyCoroutineContext
import kotlin.coroutines.resume
import kotlin.coroutines.startCoroutine
import kotlin.coroutines.suspendCoroutine

// ein Timer: ein Thread, der Aktionen nach einer Verzögerung ausführt
val timer = Executors.newSingleThreadScheduledExecutor { action -> Thread(action, "timer") }

// das Äquivalent von delay, geschrieben mit suspendCoroutine
suspend fun pause(ms: Long): Unit = suspendCoroutine { continuation ->
    display("    pause($ms): the coroutine is suspended")
    // der Timer setzt die Coroutine nach der Verzögerung fort
    timer.schedule({ continuation.resume(Unit) }, ms, TimeUnit.MILLISECONDS)
}

// eine suspendierende Funktion mit zwei Suspendierungspunkten und lokalen Variablen
suspend fun addUp(a: Int, b: Int): Int {
    display("  addUp($a, $b): start")
    val x = a * 10
    pause(300)
    display("  addUp: resumed after the 1st pause, x = $x")
    val y = b * 10
    pause(200)
    display("  addUp: resumed after the 2nd pause, x + y = ${x + y}")
    return x + y
}

fun main() {
    val end = CountDownLatch(1)
    // die abschließende Continuation: was mit dem Ergebnis der Coroutine geschehen soll
    val next = Continuation<Int>(EmptyCoroutineContext) { result ->
        display("final continuation: result = ${result.getOrThrow()}")
        end.countDown()
    }
    // ein suspendierendes Lambda, das als Coroutine mit der abschließenden Continuation gestartet wird
    val coroutine: suspend () -> Int = { addUp(4, 5) }
    display("starting the coroutine")
    coroutine.startCoroutine(next)
    display("startCoroutine has returned")
    // der Hauptthread wartet auf das Signal der abschließenden Continuation
    end.await()
    timer.shutdown()
}

// Anzeige mit vorangestelltem Namen des Threads, der sie ausführt
fun display(message: String) = println("[${Thread.currentThread().name}] $message")

Ergebnisse:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=async07.Async07Kt
[main] starting the coroutine
[main]   addUp(4, 5): start
[main]     pause(300): the coroutine is suspended
[main] startCoroutine has returned
[timer]   addUp: resumed after the 1st pause, x = 40
[timer]     pause(200): the coroutine is suspended
[timer]   addUp: resumed after the 2nd pause, x + y = 90
[timer] final continuation: result = 90

Kommentare:

  • Zeile 15: ein Timer, also ein Executor mit einem einzigen Thread namens [timer], der eine Aktion nach einer Verzögerung ausführen kann ([ScheduledExecutorService], Kapitel 8);
  • Zeilen 17–21: die Suspend-Funktion [pause], unser eigenes [delay]. Sie verwendet die Funktion [suspendCoroutine] der Standardbibliothek (deren abbrechbare Version von kotlinx.coroutines [suspendCancellableCoroutine] ist, das uns in [Async02.kt] begegnet ist): [suspendCoroutine] übergibt die Continuation der aktuellen Coroutine an den Block und suspendiert sie dann. Der Block weist den Timer an, die Continuation nach der angegebenen Verzögerung mit dem Wert [Unit] fortzusetzen;
  • Zeilen 24–33: eine Suspend-Funktion mit zwei Suspendierungspunkten (den beiden Aufrufen von [pause]) und lokalen Variablen ([a], [b], [x], [y]), die die Suspendierungen überleben müssen;
  • Zeilen 39–46: Eine Coroutine wird manuell gestartet. Die Funktion [Continuation(context) { … }] erzeugt eine Continuation aus einem Block, der das Ergebnis vom Typ [Result<Int>] erhält (ein Ergebnis oder eine Ausnahme; [getOrThrow()] gibt Ersteres zurück oder löst Letztere aus): Das ist die abschließende Continuation, die das Ergebnis anzeigt und den Hauptthread benachrichtigt. Der leere Kontext [EmptyCoroutineContext] bedeutet, dass nichts Bestimmtes angefordert wird – insbesondere kein Dispatcher. Die Erweiterungsfunktion [startCoroutine] startet ein Suspend-Lambda ([suspend () -> Int]) als Coroutine mit der abschließenden Continuation;
  • Die Ergebnisse zeigen den Ablauf: [startCoroutine] führt die Funktion [addUp] im Thread [main] bis zum ersten Suspendierungspunkt aus (Zeilen 3 und 4) und gibt dann die Kontrolle zurück (Zeile 5): Die Funktion hat [COROUTINE_SUSPENDED] zurückgegeben. 300 ms später setzt der Thread [timer] die Ausführung fort: Die Funktion [addUp] wird unmittelbar nach dem ersten Aufruf von [pause] fortgesetzt, mit unverändertem Wert von [x] (Zeile 6), in einem anderen Thread als dem, in dem sie begonnen hat. Dann folgen die zweite Pause, das Ende der Funktion und die abschließende Continuation, die das Ergebnis 90 erhält (Zeile 9). Die Coroutinen von kotlinx.coroutines tun nichts anderes; die Dispatcher legen lediglich fest, welcher Thread jede Continuation ausführt.

Sehen wir uns an, was der Compiler erzeugt hat. Das Werkzeug [javap] des JDK zeigt die Member einer kompilierten Klasse an. Gradle legt die kompilierten Klassen im Ordner [build/classes/kotlin/main] des Projekts ab:

> javap -p -cp build/classes/kotlin/main async07.Async07Kt
Compiled from "Async07.kt"
public final class async07.Async07Kt {
  private static final java.util.concurrent.ScheduledExecutorService timer;
  public static final java.util.concurrent.ScheduledExecutorService getTimer();
  public static final java.lang.Object pause(long, kotlin.coroutines.Continuation<? super kotlin.Unit>);
  public static final java.lang.Object addUp(int, int, kotlin.coroutines.Continuation<? super java.lang.Integer>);
  public static final void main();
  public static final void display(java.lang.String);
  public static void main(java.lang.String[]);
  private static final java.lang.Thread timer$lambda$0(java.lang.Runnable);
  static {};
}
  • Zeilen 6 und 7: Die Funktionen [pause] und [addUp] erhielten einen letzten Parameter vom Typ [Continuation], und ihr Rückgabetyp wurde zu [Object]. Der Continuation-Parameter von [addUp] hat denselben Typ wie sein Ergebnis: [Continuation<? super Integer>]. Aus Sicht von Java ist [addUp] eine gewöhnliche Methode, die aufgerufen werden könnte, indem man ihr eine Continuation übergibt (so kann Java-Code tatsächlich eine Suspend-Funktion aufrufen, wenn auch mit einigem Aufwand);
  • Zeile 8: die Funktion [main] ohne Parameter, neben der Methode [main(String[])], die der Compiler für die JVM hinzufügt (Zeile 10), wie wir in Kapitel 3 gesehen haben.

Der Compiler hat außerdem eine Klasse namens [Async07Kt$addUp$1] erzeugt: Dies ist das Continuation-Objekt für die Funktion [addUp]:

> javap -p -cp build/classes/kotlin/main "async07.Async07Kt$addUp$1"
Compiled from "Async07.kt"
final class async07.Async07Kt$addUp$1 extends kotlin.coroutines.jvm.internal.ContinuationImpl {
  int I$0;
  int I$1;
  int I$2;
  int I$3;
  java.lang.Object result;
  int label;
  async07.Async07Kt$addUp$1(kotlin.coroutines.Continuation<? super async07.Async07Kt$addUp$1>);
  public final java.lang.Object invokeSuspend(java.lang.Object);
}
  • Zeile 3: Die Klasse erbt von [ContinuationImpl], einer internen Klasse der Standardbibliothek, die [Continuation] implementiert;
  • Zeilen 4 bis 7: vier Ganzzahlfelder, [I$0] bis [I$3], in denen die Funktion vor jeder Suspendierung ihre lokalen Variablen [a], [b], [x], und [y] ablegt;
  • Zeile 8: [result] erhält das Ergebnis (oder die Ausnahme), mit dem die Ausführung fortgesetzt wird;
  • Zeile 9: [label], die Nummer des nächsten Wiederaufnahmepunkts;
  • Zeile 11: [invokeSuspend], die bei der Wiederaufnahme aufgerufene Methode, die lediglich die Funktion [addUp] aufruft und ihr dieses Continuation-Objekt übergibt.

Schließlich zeigt die Option [-c] von [javap] den Bytecode der Methoden an. Hier zwei Ausschnitte aus dem Bytecode von [addUp] (der Befehl [javap -c -p -cp build/classes/kotlin/main async07.Async07Kt] zeigt den gesamten Bytecode an):

        56: invokestatic  #71                 // Method kotlin/coroutines/intrinsics/IntrinsicsKt.getCOROUTINE_SUSPENDED:()Ljava/lang/Object;
        59: astore        7
        61: aload         6
        63: getfield      #97                 // Field async07/Async07Kt$addUp$1.label:I
        66: tableswitch   { // 0 to 2
                       0: 92
                       1: 153
                       2: 242
                 default: 295
            }
  • Am Einstiegspunkt der Funktion (vor dem Ausschnitt) ruft der Bytecode das Continuation-Objekt der Funktion ab, falls es sich um eine Wiederaufnahme handelt, oder erzeugt eines, wenn es der erste Aufruf ist;
  • [getCOROUTINE_SUSPENDED] liest den speziellen Wert [COROUTINE_SUSPENDED], der in einer lokalen Variablen gespeichert ist;
  • [tableswitch] ist die Anweisung der JVM, die einer [when]-Operation auf einer Ganzzahl entspricht: Abhängig vom Wert des [label]-Feldes (0, 1 oder 2) springt die Ausführung zum Anfang der Funktion (Adresse 92), unmittelbar hinter den ersten Aufruf von [pause] (Adresse 153) oder unmittelbar hinter den zweiten (Adresse 242). Jeder andere Wert führt zu einem Fehler (Adresse 295).
       112: ldc2_w        #115                // long 300l
       115: aload         6
       117: aload         6
       119: iload_0
       120: putfield      #119                // Field async07/Async07Kt$addUp$1.I$0:I
       123: aload         6
       125: iload_1
       126: putfield      #122                // Field async07/Async07Kt$addUp$1.I$1:I
       129: aload         6
       131: iload_3
       132: putfield      #125                // Field async07/Async07Kt$addUp$1.I$2:I
       135: aload         6
       137: iconst_1
       138: putfield      #97                 // Field async07/Async07Kt$addUp$1.label:I
       141: invokestatic  #127                // Method pause:(JLkotlin/coroutines/Continuation;)Ljava/lang/Object;
       144: dup
       145: aload         7
       147: if_acmpne     178
       150: aload         7
       152: areturn
       153: aload         6
       155: getfield      #125                // Field async07/Async07Kt$addUp$1.I$2:I
       158: istore_3
       159: aload         6
       161: getfield      #122                // Field async07/Async07Kt$addUp$1.I$1:I
       164: istore_1
       165: aload         6
       167: getfield      #119                // Field async07/Async07Kt$addUp$1.I$0:I
       170: istore_0
       171: aload         5
       173: invokestatic  #109                // Method kotlin/ResultKt.throwOnFailure:(Ljava/lang/Object;)V
       176: aload         5
  • Adressen 112 bis 138: Vor dem ersten Aufruf von [pause] speichert die Funktion ihre lokalen Variablen [a], [b] und [x] (die Variablen 0, 1 und 3 der JVM) in den Feldern [I$0], [I$1] und [I$2] des Continuation-Objekts und setzt [label] auf 1;
  • Adresse 141: der Aufruf von [pause(300)], wobei das Continuation-Objekt als letzter Parameter übergeben wird;
  • Adressen 144 bis 152: Wenn [pause] den Wert [COROUTINE_SUSPENDED] zurückgegeben hat, gibt die Funktion ihrerseits [COROUTINE_SUSPENDED] an ihren Aufrufer zurück ([areturn]): So „wandert“ die Suspendierung den Aufrufstapel hinauf bis zu [startCoroutine], das die Kontrolle an den Thread [main] zurückgibt. Andernfalls wird die Ausführung direkt bei Adresse 178 fortgesetzt;
  • Adressen 153 bis 170: Wiederaufnahmepunkt Nr. 1. Die Funktion kopiert die Felder des Continuation-Objekts in ihre lokalen Variablen und fährt dann fort, als wäre nichts geschehen.

Der Aufrufstapel der JVM bleibt daher nie erhalten: Bei jeder Suspendierung geben alle gerade suspendierten Funktionen [COROUTINE_SUSPENDED] zurück, und ihre Stack-Frames verschwinden; was erhalten bleiben muss, wird in den Continuation-Objekten gespeichert, die miteinander verkettet sind (jedes kennt die Continuation seines Aufrufers). Bei jeder Wiederaufnahme wird die Kette in umgekehrter Reihenfolge durchlaufen. Dies ist dasselbe Konzept wie die „Zustandsmaschine“, die der C#-Compiler für eine [async]-Methode erzeugt.

Um diesen Mechanismus vollständig zu verstehen, schreibt das Programm [Async08.kt] in Kotlin manuell eine vereinfachte Version dessen, was der Compiler für [pause] und [addUp] erzeugt hat:

// die Zustandsmaschine, die der Compiler für eine suspendierende Funktion erzeugt, von Hand geschrieben
// (vereinfachte Version dessen, was er für die Funktion [addUp] des Programms Async07 erzeugt)
package async08

import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import kotlin.coroutines.Continuation
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext
import kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED

// ein Timer: ein Thread, der Aktionen nach einer Verzögerung ausführt
val timer = Executors.newSingleThreadScheduledExecutor { action -> Thread(action, "timer") }

// die "kompilierte" Funktion pause: sie erhält die fortzusetzende Continuation und gibt COROUTINE_SUSPENDED zurück
fun pause(ms: Long, continuation: Continuation<Unit>): Any {
    display("    pause($ms): the coroutine is suspended")
    timer.schedule({ continuation.resumeWith(Result.success(Unit)) }, ms, TimeUnit.MILLISECONDS)
    return COROUTINE_SUSPENDED
}

// die Continuation von [addUp]: der Zustand der Maschine und die zu behaltenden lokalen Variablen
class AddUpContinuation(val caller: Continuation<Int>, val a: Int, val b: Int) : Continuation<Unit> {
    // die Nummer des nächsten Fortsetzungspunkts
    var label = 0
    // die lokalen Variablen, die die Suspendierungen überdauern müssen
    var x = 0
    var y = 0
    override val context: CoroutineContext get() = caller.context

    // wird am Ende einer Pause aufgerufen: die Zustandsmaschine wird dort neu gestartet, wo sie angehalten hatte
    override fun resumeWith(result: Result<Unit>) {
        val outcome = addUp(this)
        // wenn die Funktion bis zum Ende gelaufen ist, wird die Continuation des Aufrufers fortgesetzt
        if (outcome !== COROUTINE_SUSPENDED) {
            caller.resumeWith(Result.success(outcome as Int))
        }
    }
}

// die Funktion [addUp], in eine Zustandsmaschine umgewandelt: sie wird am Anfang und dann bei jeder Fortsetzung betreten
fun addUp(state: AddUpContinuation): Any {
    while (true) {
        when (state.label) {
            0 -> {
                display("  addUp(${state.a}, ${state.b}): start (label 0)")
                state.x = state.a * 10
                // der nächste Fortsetzungspunkt ist Nr. 1
                state.label = 1
                if (pause(300, state) === COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
            }
            1 -> {
                display("  addUp: resumed after the 1st pause (label 1), x = ${state.x}")
                state.y = state.b * 10
                state.label = 2
                if (pause(200, state) === COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
            }
            2 -> {
                display("  addUp: resumed after the 2nd pause (label 2), x + y = ${state.x + state.y}")
                return state.x + state.y
            }
            else -> error("unknown resumption point: ${state.label}")
        }
    }
}

fun main() {
    val end = CountDownLatch(1)
    // die abschließende Continuation: was mit dem Ergebnis geschehen soll
    val next = Continuation<Int>(EmptyCoroutineContext) { result ->
        display("final continuation: result = ${result.getOrThrow()}")
        end.countDown()
    }
    display("first call of addUp")
    val returned = addUp(AddUpContinuation(next, 4, 5))
    display("addUp returned ${if (returned === COROUTINE_SUSPENDED) "COROUTINE_SUSPENDED" else returned}")
    end.await()
    timer.shutdown()
}

// Anzeige mit vorangestelltem Namen des Threads, der sie ausführt
fun display(message: String) = println("[${Thread.currentThread().name}] $message")

Ergebnisse:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=async08.Async08Kt
[main] first call of addUp
[main]   addUp(4, 5): start (label 0)
[main]     pause(300): the coroutine is suspended
[main] addUp returned COROUTINE_SUSPENDED
[timer]   addUp: resumed after the 1st pause (label 1), x = 40
[timer]     pause(200): the coroutine is suspended
[timer]   addUp: resumed after the 2nd pause (label 2), x + y = 90
[timer] final continuation: result = 90

Kommentare:

  • Zeilen 16–20: Die Funktion [pause] aus Sicht des Compilers: eine gewöhnliche Funktion (ohne [suspend]), die die fortzusetzende Continuation erhält, ihre Wiederaufnahme einplant und [COROUTINE_SUSPENDED] zurückgibt, eine Konstante aus dem Paket [kotlin.coroutines.intrinsics] der Standardbibliothek;
  • Zeilen 23–29: das Continuation-Objekt von [addUp]. Es kennt die Continuation des Aufrufers ([caller]), die Parameter [a] und [b], die Nummer des nächsten Wiederaufnahmepunkts ([label]) und die lokalen Variablen [x] und [y]. Der Compiler seinerseits speichert die Parameter ebenfalls in Feldern und verwendet generische Felder wieder ([I$0]…);
  • Zeile 30: Eine Continuation muss den Kontext ihrer Coroutine bereitstellen; wir verwenden den des Aufrufers;
  • Zeilen 33–37: Wiederaufnahme. Der Timer ruft am Ende einer Pause [resumeWith] auf; die Methode ruft [addUp] erneut mit dem Continuation-Objekt auf, das weiß, wo fortzufahren ist. Läuft die Funktion bis zum Ende durch (sie gibt nicht [COROUTINE_SUSPENDED] zurück), wird ihr Ergebnis an die Continuation des Aufrufers weitergereicht: So „wandert“ das Ergebnis von einer Suspend-Funktion „zurück“ zu der Funktion, die sie aufgerufen hat;
  • Zeilen 42–63: die Zustandsmaschine. Der Aufruf von [when] auf [state.label] leitet die Ausführung zum richtigen Abschnitt der Funktion. Jeder Abschnitt endet damit, dass er den nächsten Wiederaufnahmepunkt speichert und [pause] aufruft: Gibt [pause] den Wert [COROUTINE_SUSPENDED] zurück, gibt die Funktion ihn ebenfalls zurück; andernfalls (eine Suspend-Funktion kann bis zum Ende laufen, ohne zu suspendieren, zum Beispiel wenn das Ergebnis bereits bekannt ist) springt die Schleife [while (true)] direkt zum nächsten Abschnitt. Lokale Variablen werden aus dem Continuation-Objekt gelesen und in dieses geschrieben ([state.x], [state.y]);
  • Zeilen 76–77: der erste Aufruf. Die Ergebnisse zeigen, dass [addUp] den Wert [COROUTINE_SUSPENDED] zurückgegeben hat (Zeile 5 der Ergebnisse); der Rest des Ablaufs findet im Thread [timer] statt, genau wie bei [Async07.kt].

Dieses Programm dient ausschließlich der Veranschaulichung: Sie würden diesen Code nie selbst schreiben. Es lassen sich jedoch zwei wesentliche Erkenntnisse mitnehmen:

  • Eine suspendierte Coroutine kostet nur ihre Continuation-Objekte – einige Dutzend Byte pro aktiver Funktion –, statt eines Stacks von einem Megabyte wie bei einem Plattform-Thread: Dadurch wurden die 100.000 Coroutinen in [Async01.kt] möglich;
  • Eine Suspendierung ist nur bei Aufrufen von Suspend-Funktionen möglich. Eine gewöhnliche Funktion kann nicht suspendiert werden: Blockiert sie (wie [Thread.sleep]), blockiert sie den Thread. Dies ist der grundlegende Unterschied zu virtuellen Threads, bei denen die JVM jeden in Java geschriebenen blockierenden Code suspendieren kann. Coroutinen hängen dagegen nicht von der JVM ab: Derselbe Mechanismus funktioniert mit Kotlin/JS in einem Single-Thread-Browser und mit Kotlin/Native.

9.3.4. Dispatcher: Welcher Thread führt den Rest des Codes aus?

Eine Coroutine ist kein Thread: Zu ihrer Ausführung werden Threads benötigt. Die Komponente, die entscheidet, welcher Thread eine Coroutine ausführt – beim Start und danach bei jeder Wiederaufnahme –, ist ihr Dispatcher, ein Element des Kontexts der Coroutine. Der Kontext einer Coroutine ([CoroutineContext]) ist eine kleine Menge von Elementen, die nach ihrem Typ indiziert sind und mit dem Operator [+] kombiniert werden: der Dispatcher ([CoroutineDispatcher]), der [Job] der Coroutine, ihr Name ([CoroutineName]) und ihr Exception-Handler ([CoroutineExceptionHandler], den wir später besprechen werden) … Ein Kontext wird als Parameter an [launch], [async], [runBlocking], oder [withContext] übergeben; die neue Coroutine erbt die Elemente des Kontexts ihres Scopes, mit Ausnahme der überschriebenen.

kotlinx.coroutines stellt vier Dispatcher bereit, die Eigenschaften des Objekts [Dispatchers] sind:

Dispatcher
Verwendete Threads
[Dispatchers.Default]
Ein Thread-Pool für Berechnungen mit so vielen Threads, wie Prozessoren vorhanden sind (mindestens zwei). Dies ist der Dispatcher, der verwendet wird, wenn keiner angegeben ist und der Scope keinen hat.
[Dispatchers.IO]
Ein Thread-Pool für blockierende Operationen (Dateien, JDBC, blockierende Sockets), der bis zu 64 Threads enthalten kann (oder mehr, wenn der Rechner mehr als 64 Prozessoren hat; die Systemeigenschaft [kotlinx.coroutines.io.parallelism] ändert dieses Limit). Er teilt seine Threads mit [Dispatchers.Default], was einen Thread-Wechsel beim Umschalten zwischen beiden vermeidet.
[Dispatchers.Main]
Der GUI-Thread. Er existiert nur, wenn das entsprechende Modul zum Projekt hinzugefügt wird: [kotlinx-coroutines-android], [kotlinx-coroutines-swing], [kotlinx-coroutines-javafx].
[Dispatchers.Unconfined]
Kein bestimmter Thread: Die Coroutine startet im Thread des Aufrufers und wird nach einer Suspendierung in dem Thread fortgesetzt, der sie wieder aufgenommen hat. Er wird hauptsächlich für Tests und sehr spezielle Fälle verwendet.

Zusätzlich zu diesen Dispatchern gibt es den von [runBlocking], der seine Coroutinen in dem Thread ausführt, der ihn aufgerufen hat, sowie die Dispatcher, die aus einem Java-Executor mit der Erweiterungsfunktion [asCoroutineDispatcher()] erstellt werden. Das Programm [Async09.kt] zeigt den Thread an, der jeden Codeabschnitt ausführt:

// welcher Thread führt eine Coroutine und den Rest ihres Codes nach einer Suspendierung aus? die Dispatcher
package async09

import kotlinx.coroutines.CoroutineName
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.asCoroutineDispatcher
import kotlinx.coroutines.delay
import kotlinx.coroutines.joinAll
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import java.util.concurrent.Executors

fun main() {
    // der Debug-Modus ergänzt den Thread-Namen um Namen und Nummer der ausgeführten Coroutine
    System.setProperty("kotlinx.coroutines.debug", "on")
    display("start of the program, ${Runtime.getRuntime().availableProcessors()} processors")
    runBlocking(CoroutineName("main")) {
        // 1 - die Coroutine von runBlocking wird von dem Thread ausgeführt, der runBlocking aufgerufen hat
        display("1 - runBlocking, before delay")
        delay(100)
        display("1 - runBlocking, after delay")

        // 2 - Dispatchers.Default: ein für Berechnungen dimensionierter Thread-Pool
        launch(Dispatchers.Default + CoroutineName("computation")) {
            display("2 - Dispatchers.Default")
        }.join()

        // 3 - Dispatchers.IO: ein größerer Thread-Pool für blockierende Operationen
        launch(Dispatchers.IO + CoroutineName("io")) {
            display("3 - Dispatchers.IO")
        }.join()

        // 4 - withContext wechselt den Dispatcher für die Dauer eines Blocks, innerhalb derselben Coroutine
        val result = withContext(Dispatchers.Default) {
            display("4 - in withContext(Dispatchers.Default)")
            42
        }
        display("4 - back on the runBlocking thread, result = $result")

        // 5 - Dispatchers.Unconfined: der Rest wird von dem Thread ausgeführt, der die Coroutine fortsetzt
        launch(Dispatchers.Unconfined + CoroutineName("free")) {
            display("5 - Dispatchers.Unconfined, before delay")
            delay(100)
            display("5 - Dispatchers.Unconfined, after delay")
        }.join()

        // 6 - ein Java-Executor, in einen Dispatcher umgewandelt: hier ein virtueller Thread pro Task
        Executors.newVirtualThreadPerTaskExecutor().asCoroutineDispatcher().use { virtuals ->
            launch(virtuals + CoroutineName("virtual")) {
                display("6 - virtual threads, before delay")
                delay(100)
                display("6 - virtual threads, after delay")
            }.join()
        }

        // 7 - auf Dispatchers.Default kann eine Coroutine nach jeder Suspendierung den Thread wechseln
        val a = launch(Dispatchers.Default + CoroutineName("A")) { work("A") }
        val b = launch(Dispatchers.Default + CoroutineName("B")) { work("B") }
        joinAll(a, b)
        display("end of the program")
    }
}

suspend fun work(name: String) {
    for (i in 1..3) {
        display("7 -   $name$i")
        delay(100)
    }
}

// Anzeige mit vorangestelltem ausführenden Thread (bei einem virtuellen Thread seine vollständige Beschreibung)
fun display(message: String) {
    val thread = Thread.currentThread()
    println("[${if (thread.isVirtual) thread.toString() else thread.name}] $message")
}

Ergebnisse:

> gradlew -q run -Pmain=async09.Async09Kt
[main] start of the program, 2 processors
[main @main#1] 1 - runBlocking, before delay
[main @main#1] 1 - runBlocking, after delay
[DefaultDispatcher-worker-1 @computation#2] 2 - Dispatchers.Default
[DefaultDispatcher-worker-1 @io#3] 3 - Dispatchers.IO
[DefaultDispatcher-worker-1 @main#1] 4 - in withContext(Dispatchers.Default)
[main @main#1] 4 - back on the runBlocking thread, result = 42
[main @free#4] 5 - Dispatchers.Unconfined, before delay
[kotlinx.coroutines.DefaultExecutor @free#4] 5 - Dispatchers.Unconfined, after delay
[VirtualThread[#25, @virtual#5]/runnable@ForkJoinPool-1-worker-1] 6 - virtual threads, before delay
[VirtualThread[#28, @virtual#5]/runnable@ForkJoinPool-1-worker-1] 6 - virtual threads, after delay
[DefaultDispatcher-worker-1 @A#6] 7 -   A1
[DefaultDispatcher-worker-2 @B#7] 7 -   B1
[DefaultDispatcher-worker-1 @A#6] 7 -   A2
[DefaultDispatcher-worker-1 @B#7] 7 -   B2
[DefaultDispatcher-worker-1 @A#6] 7 -   A3
[DefaultDispatcher-worker-1 @B#7] 7 -   B3
[main @main#1] end of the program

Kommentare:

  • Zeile 16: Die Systemeigenschaft [kotlinx.coroutines.debug] aktiviert den Debug-Modus für kotlinx.coroutines (sie muss gesetzt werden, bevor die Bibliothek erstmals verwendet wird; sie kann auch an die JVM übergeben werden: [-Dkotlinx.coroutines.debug]). In diesem Modus wird dem Namen des Threads, der eine Coroutine ausführt, während der Ausführung der Name der Coroutine (bereitgestellt durch ein [CoroutineName]-Element in ihrem Kontext oder standardmäßig [coroutine] ) und ihre Nummer angefügt: [main @main#1];
  • Zeilen 18–22: Die Coroutine von [runBlocking] mit dem Namen [main] wird vom Thread [main] ausgeführt, sowohl vor als auch nach dem Warten: [runBlocking] verwandelt den aufrufenden Thread in eine Ereignisschleife, die seine Coroutinen ausführt (Zeilen 3 und 4 der Ergebnisse);
  • Zeilen 24–26: eine Coroutine, die auf [Dispatchers.Default] gestartet wird und deren Kontext – gebildet mit [+] – aus einem Dispatcher und einem Namen besteht; sie wird von einem Thread mit dem Namen [DefaultDispatcher-worker-N] ausgeführt (Zeile 5);
  • Zeilen 29–31: eine Coroutine, die auf [Dispatchers.IO] gestartet wird; sie wird von einem Thread mit demselben Namen ausgeführt (Zeile 6), da die beiden Dispatcher ihre Threads teilen;
  • Zeilen 34–39: [withContext(context) { … }] ist eine Suspend-Funktion, die einen Block in einem anderen Kontext ausführt – hier einem anderen Dispatcher – innerhalb derselben Coroutine (die Nummer bleibt [#1]), dann zum ursprünglichen Dispatcher zurückkehrt und das Ergebnis des Blocks zurückgibt (Zeilen 7 und 8). Dies ist die bevorzugte Methode, um eine Berechnung auf [Dispatchers.Default] oder blockierenden Code auf [Dispatchers.IO] auszuführen, ohne die Form des Codes zu ändern: [val text = withContext(Dispatchers.IO) { file.readText() }];
  • Zeilen 41–45: Bei [Dispatchers.Unconfined] startet die Coroutine im Thread [main] – dem Thread des Aufrufers (Zeile 9) – und wird nach [delay] in dem Thread fortgesetzt, der sie wieder aufgenommen hat: [kotlinx.coroutines.DefaultExecutor], dem Timer-Thread von kotlinx.coroutines, der die Timeouts verwaltet (Zeile 10). Dies ist das Verhalten der nicht asynchronen Continuations von [CompletableFuture] ([thenApply], [thenRun]), die von dem Thread ausgeführt werden, der die Operation abschließt;
  • Zeilen 48–54: [Executors.newVirtualThreadPerTaskExecutor().asCoroutineDispatcher()] erstellt einen Dispatcher, der jeden Ausführungsabschnitt der Coroutine einem Java-Executor zuweist – hier einem Executor für virtuelle Threads. Der entstehende Dispatcher muss geschlossen werden, wenn er nicht mehr benötigt wird, daher [use]. Die Zeilen 11 und 12 zeigen, dass der Anfang und der Rest der Coroutine von zwei verschiedenen virtuellen Threads ausgeführt wurden (Nr. 25 und 28): Jede Wiederaufnahme ist eine neue Aufgabe, die dem Executor zugewiesen wird, der daher einen neuen virtuellen Thread erzeugt. Ein solcher Dispatcher ist nützlich, um blockierenden Code aus Coroutinen auszuführen, ohne durch die Obergrenze von 64 Threads von [Dispatchers.IO] eingeschränkt zu sein: Die virtuellen Threads werden von der JVM freigegeben, solange sie warten;
  • Zeilen 57–60: zwei Coroutinen, die eine Meldung anzeigen und dann dreimal hintereinander warten, auf [Dispatchers.Default]. [joinAll] wartet auf das Ende mehrerer Coroutinen. Die Zeilen 13 bis 18 zeigen, dass eine Coroutine nicht an einen einzigen Thread gebunden bleibt: Coroutine B startet auf [worker-2] und wird auf [worker-1] fortgesetzt. In einer Coroutine darf man daher nie davon ausgehen, dass der Code nach einer Suspendierung von demselben Thread ausgeführt wird wie der Code davor. Eine praktische Folge: Eine Variable [ThreadLocal] (Kapitel 8) ist in einer Coroutine unzuverlässig; stattdessen werden die Informationen im Kontext der Coroutine gespeichert, der ihr überallhin folgt;
  • Zeilen 72–75: Für einen virtuellen Thread – dessen Name standardmäßig leer ist – zeigen wir seine vollständige Beschreibung an, die seine Nummer, seinen Namen (hier den der Coroutine, hinzugefügt vom Debug-Modus) und seinen Host-Thread enthält.

Die Wahl des Dispatchers ist daher wichtig:

  • [Dispatchers.Default] für Berechnungen. Eine Coroutine, die eine lange Berechnung durchführt, belegt einen seiner Threads, genau wie eine Aufgabe in einem Thread-Pool: Coroutinen beschleunigen keine Berechnungen; sie erleichtern die Nebenläufigkeit wartender Operationen (die gleichzeitige Behandlung vieler wartender Operationen), nicht die Parallelität von Berechnungen (die gleichzeitige Ausführung mehrerer Berechnungen auf mehreren Prozessoren, wie im vorherigen Kapitel besprochen);
  • [Dispatchers.IO] oder ein Dispatcher für virtuelle Threads für blockierenden Code, zusammen mit [withContext];
  • [Dispatchers.Main] in einer grafischen Anwendung: Eine im UI-Thread gestartete Coroutine kann die grafischen Komponenten aktualisieren, auf eine Operation warten (die anderswo mit [withContext] ausgeführt wird), ohne die Benutzeroberfläche einzufrieren, und dann die Benutzeroberfläche mit dem Ergebnis aktualisieren, ohne dass eine besondere Behandlung nötig wäre: Am Ende von [withContext] kehrt die Coroutine automatisch in den UI-Thread zurück. So funktioniert es in C#, wo die Continuation einer [async]-Methode in den Oberflächen-Thread zurückkehrt, und Java erlaubt dies nicht, ohne jeder Continuation ausdrücklich einen Executor zu übergeben.

Schließlich können Sie die Anzahl der Threads, die ein Dispatcher einer Gruppe von Coroutinen zuweist, mit [limitedParallelism(n)] begrenzen: [val base = Dispatchers.IO.limitedParallelism(10)] gibt einen Dispatcher zurück, der nie mehr als 10 Coroutinen gleichzeitig ausführt und dabei auf die Threads von [Dispatchers.IO] zurückgreift. Mit [limitedParallelism(1)] erhalten wir einen Dispatcher, der immer nur eine Coroutine gleichzeitig ausführt, was die sperrenfreie Manipulation gemeinsamen Zustands ermöglicht. Diese Funktion, die seit Version 1.9 von kotlinx.coroutines stabil ist, wird später in diesem Kapitel im Abschnitt über begrenzte Parallelität verwendet.

9.3.5. Das Hauptprogramm

Ein Programm, das Coroutinen verwendet, muss die erste Coroutine aus dem normalen Code der Funktion [main] starten und auf ihr Ende warten: Andernfalls würde die Funktion [main] sofort enden und das Programm mit ihr (Dispatcher-Threads sind Daemon-Threads, die die JVM nicht am Beenden hindern). Dafür gibt es zwei Möglichkeiten:

  • [fun main() = runBlocking { … }], die wir seit Beginn des Kapitels verwenden: [runBlocking] blockiert den Thread [main] bis zum Ende der Coroutine und aller von ihr gestarteten Coroutinen. Dies ist der einzige Ort, an dem ein blockierendes Warten normal ist; Sie dürfen [runBlocking] niemals aus einer Coroutine oder einer Suspend-Funktion aufrufen, da es deren Thread blockiert. Wenn der letzte Ausdruck im Block nicht vom Typ [Unit] ist, schreiben wir [runBlocking<Unit> { … }]; andernfalls hätte die Funktion [main] einen anderen Rückgabetyp, und die JVM würde sie nicht mehr als Hauptprogramm erkennen;
  • [suspend fun main()]: Die Funktion [main] kann selbst eine Suspend-Funktion sein; der Compiler übernimmt das Starten als Coroutine. Dies entspricht der Methode [static async Task Main()] in C#.

Das Programm [Async10.kt] führt einen Countdown mit einer Suspend-Funktion [main] durch:

// eine suspendierende main-Funktion: ein Countdown und der Exit-Code des Programms
package async10

import kotlinx.coroutines.delay
import kotlin.system.exitProcess

suspend fun main(args: Array<String>) {
    // die Anzahl der Sekunden wird als Argument übergeben
    val nbSeconds = args.singleOrNull()?.toIntOrNull()
    if (nbSeconds == null || nbSeconds < 0) {
        println("syntax: gradlew -q run -Pmain=async10.Async10Kt --args=\"nbSeconds\"")
        // der Exit-Code des Programms: 0 bei Erfolg, etwas anderes bei einem Fehler
        exitProcess(1)
    }
    println("countdown started on thread [${Thread.currentThread().name}]")
    countdown(nbSeconds)
    println("finished, on thread [${Thread.currentThread().name}]")
}

// eine gewöhnliche Schleife: jedes delay setzt die Funktion aus, ohne einen Thread zu blockieren
suspend fun countdown(nbSeconds: Int) {
    for (i in nbSeconds downTo 1) {
        println("$i s left")
        delay(1000)
    }
}

Ergebnisse, zuerst mit und dann ohne Argument:

1
2
3
4
5
6
> gradlew -q run -Pmain=async10.Async10Kt --args="3"
countdown started on thread [main]
3 s left
2 s left
1 s left
finished, on thread [kotlinx.coroutines.DefaultExecutor]
> gradlew -q run -Pmain=async10.Async10Kt
syntax: gradlew -q run -Pmain=async10.Async10Kt --args="nbSeconds"

Kommentare:

  • Zeile 7: eine [main] Suspend-Funktion, die über Gradle mit der Option [--args] übergebene Befehlszeilenargumente erhält;
  • Zeile 9: [singleOrNull()] gibt das einzige Argument zurück oder [null] , wenn es nicht genau eines gibt, und [toIntOrNull()] wandelt es in eine Ganzzahl um oder gibt [null] zurück, wenn es keine Ganzzahl ist;
  • Zeilen 10–13: Fehlt das Argument oder ist es fehlerhaft, endet das Programm mit [exitProcess(1)] (einer Funktion aus [kotlin.system], die [System.exit] aufruft). Die übergebene Ganzzahl 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 %ERRORLEVEL%] unter Windows, [echo $?] unter Linux. Wenn ein Programm von Gradle gestartet wird und mit einem anderen Code als 0 endet, schlägt die Task [run] fehl, und Gradle zeigt dann nach denen des Programms eigene Fehlermeldungen an (diese sind hier nicht wiedergegeben). Der Typ von [exitProcess] ist [Nothing] (Kapitel 3): Der Compiler weiß, dass diese Funktion nie zurückkehrt, und geht daher davon aus, dass nach dem [if] die Variable [nbSeconds] nicht [null] ist; sie kann als [Int] verwendet werden (Smart Cast);
  • Zeilen 20–24: der Countdown. Das Java-Programm musste dies per Rekursion umsetzen, wobei jeder Schritt mit [thenCompose] an den nächsten gekettet wurde; hier ist es eine gewöhnliche Schleife mit einem [delay] in jeder Iteration;
  • Die Ergebnisse zeigen eine Besonderheit von [suspend fun main]: Ihre Coroutine hat keinen Dispatcher. Sie startet im Thread [main] und wird dann nach dem Warten in dem Thread fortgesetzt, der sie wieder aufgenommen hat – dem Timer-Thread von kotlinx.coroutines ([kotlinx.coroutines.DefaultExecutor]) –, genau wie bei [Dispatchers.Unconfined]. Das hat hier keine Folgen, ist aber ein Grund, [fun main() = runBlocking { … }] vorzuziehen, dessen Verhalten besser definiert ist, oder mit [withContext] im Rumpf der Funktion einen Dispatcher anzugeben.

9.4. Strukturierte Nebenläufigkeit

Der Java-Kurs schloss sein Kapitel mit einem Überblick über strukturierte Nebenläufigkeit ([StructuredTaskScope], in Java 25 noch in der Preview-Phase) ab. In Kotlin ist dies nicht nur eine Ergänzung: Es ist das Prinzip, auf dem die gesamte Bibliothek kotlinx.coroutines beruht, und Sie müssen es verstehen, bevor Sie weitermachen.

Die Idee ist einfach: Eine Coroutine kann nur innerhalb eines Scopes gestartet werden ([CoroutineScope]), und der Scope endet erst, wenn die von ihm gestarteten Coroutinen beendet sind. Die Funktionen [launch] und [async] sind Erweiterungsfunktionen von [CoroutineScope]: Sie können nicht an beliebiger Stelle aufgerufen werden, sondern nur innerhalb eines Scopes, etwa im Block eines [runBlocking], eines [launch] oder eines [async], deren Receiver ([this]) ein Scope ist. Jeder Scope hat einen [Job]; jede innerhalb des Scopes gestartete Coroutine hat ihren eigenen [Job], der zu einem Kind des [Job] des Scopes wird. Die Coroutinen eines Programms bilden so einen Baum, dessen Eltern-Kind-Beziehungen drei Konsequenzen haben:

Image

  • Ein Elternteil wartet auf seine Kinder: Ein *[Job] endet erst, wenn sein eigener Code und alle seine Kinder beendet sind. Deshalb hat *[runBlocking] auf die in seinem Block gestarteten Coroutinen gewartet, ohne dass dafür Code geschrieben werden musste;
  • Der Abbruch wird nach unten weitergegeben: Der Abbruch eines [Job] bricht alle seine Kinder und deren Kinder ab;
  • Ein Fehler wird nach oben weitergegeben: Schlägt ein Kind fehl (sein Code wirft eine Ausnahme), wird sein Elternteil abgebrochen, wodurch wiederum alle seine anderen Kinder abgebrochen werden, und die Ausnahme wird an den Elternteil weitergereicht, dann an dessen Elternteil, bis hin zur Wurzel oder zu einem Codeabschnitt, der sie behandelt.

Folglich kann keine Coroutine „vergessen“ werden: Sie lebt innerhalb eines Scopes, der nicht ohne sie enden kann; wenn sie fehlschlägt, erfährt es jemand; wenn die Operation, zu der sie gehört, aufgegeben wird, wird sie beendet. Dies ist dieselbe Disziplin wie bei Codeblöcken in der strukturierten Programmierung (ein Block endet nicht vor den Anweisungen, die er enthält), angewandt auf die Nebenläufigkeit – daher der Name.

Das Programm [Async11.kt] veranschaulicht diese drei Regeln:

// strukturierte Nebenläufigkeit: Job, Eltern und Kinder, coroutineScope
package async11

import kotlinx.coroutines.async
import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.job
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

var start = System.nanoTime()

fun main() = runBlocking<Unit> {
    // 1 - die von einer Coroutine gestarteten Coroutinen sind ihre Kinder: die Eltern warten auf deren Ende
    val parent = launch {
        launch {
            delay(300)
            display("  child 1 finished")
        }
        launch {
            delay(600)
            display("  child 2 finished")
        }
        val nbChildren = coroutineContext.job.children.count()
        display("  the parent launched $nbChildren children, its code is finished")
    }
    delay(100)
    display("1 - parent: isActive=${parent.isActive}, isCompleted=${parent.isCompleted}, " +
            "children=${parent.children.count()}")
    parent.join()
    display("1 - parent: isActive=${parent.isActive}, isCompleted=${parent.isCompleted}")

    // 2 - coroutineScope: die Funktion startet Coroutinen und kehrt erst nach deren Ende zurück
    start = System.nanoTime()
    val tray = prepareBreakfast()
    display("2 - breakfast served: $tray")

    // 3 - das Abbrechen der Eltern bricht alle ihre Kinder ab
    start = System.nanoTime()
    val parent3 = launch {
        for (number in 1..2) {
            launch {
                try {
                    delay(10_000)
                } finally {
                    display("  child $number: cancelled")
                }
            }
        }
    }
    delay(200)
    parent3.cancelAndJoin()
    display("3 - parent cancelled: isCancelled=${parent3.isCancelled}")

    // 4 - der Fehlschlag eines Kindes bricht seine Geschwister ab und steigt zu den Eltern auf
    start = System.nanoTime()
    try {
        coroutineScope {
            launch {
                try {
                    delay(10_000)
                } finally {
                    display("  the sibling is cancelled")
                }
            }
            launch {
                delay(200)
                throw IllegalStateException("the toaster burned")
            }
        }
    } catch (e: IllegalStateException) {
        display("4 - coroutineScope threw: ${e.message}")
    }
}

// drei gleichzeitig ausgeführte Vorbereitungen; die Funktion kehrt erst zurück, wenn alle beendet sind
suspend fun prepareBreakfast(): String = coroutineScope {
    val coffee = async { prepare("coffee", 1000) }
    val toast = async { prepare("toast", 600) }
    // eine Coroutine ohne Ergebnis: coroutineScope wartet auch auf sie
    launch { prepare("table set", 300) }
    "${coffee.await()} and ${toast.await()}"
}

// eine Vorbereitung, die [ms] Millisekunden dauert
suspend fun prepare(what: String, ms: Long): String {
    display("  $what: start")
    delay(ms)
    display("  $what: ready")
    return what
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) = println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async11.Async11Kt
   48 ms :   the parent launched 2 children, its code is finished
  142 ms : 1 - parent: isActive=true, isCompleted=false, children=2
  361 ms :   child 1 finished
  661 ms :   child 2 finished
  664 ms : 1 - parent: isActive=false, isCompleted=true
    4 ms :   coffee: start
    4 ms :   toast: start
    4 ms :   table set: start
  304 ms :   table set: ready
  604 ms :   toast: ready
 1004 ms :   coffee: ready
 1011 ms : 2 - breakfast served: coffee and toast
  204 ms :   child 1: cancelled
  204 ms :   child 2: cancelled
  205 ms : 3 - parent cancelled: isCancelled=true
  201 ms :   the sibling is cancelled
  202 ms : 4 - coroutineScope threw: the toaster burned

Kommentare:

  • Zeile 14: Der letzte Ausdruck im Block ist ein [try]-Ausdruck, dessen Typ nicht [Unit] ist; daher wird der Typ des Ergebnisses von [runBlocking] angegeben, wie im vorigen Absatz erläutert;
  • Zeilen 15–26: Eine [parent]-Coroutine startet zwei Kinder, die 300 bzw. 600 ms laufen, und zeigt dann die Anzahl ihrer Kinder an: Innerhalb des Blocks eines [launch] ist [coroutineContext] der Kontext der Coroutine, [coroutineContext.job] ist ihr [Job], und die Eigenschaft [children] des Letzteren ist die Sequenz seiner Kinder. Der Code des Elternteils endet sofort (Zeile 2 der Ergebnisse);
  • Zeilen 28–30: 100 ms später ist der [Job] des Elternteils zusammen mit seinen beiden Kindern noch aktiv (Zeile 3): Ein [Job] , dessen Code beendet ist, wartet auf seine Kinder;
  • Zeilen 31–32: [join()] gibt die Kontrolle erst 600 ms später zurück, wenn das zweite Kind beendet ist (Zeilen 4–6);
  • Zeilen 77–83: Die Suspend-Funktion [prepareBreakfast] erledigt drei Zubereitungen gleichzeitig. Um Coroutinen zu starten, benötigt eine Suspend-Funktion einen Scope: [coroutineScope { … }] erstellt einen neuen Scope, dessen [Job] ein Kind der aufrufenden Coroutine ist, führt den Block aus, wartet, bis alle im Block gestarteten Coroutinen beendet sind, und gibt dann den Wert des Blocks zurück. Die Funktion [prepareBreakfast] erscheint von außen also als gewöhnliche sequenzielle Funktion: Wenn sie die Kontrolle zurückgibt, ist alles, was sie gestartet hat, abgeschlossen, einschließlich der Coroutine in Zeile 82, auf deren Ende niemand ausdrücklich wartet;
  • Zeilen 34–37: der Funktionsaufruf; das Frühstück wird nach einer Sekunde serviert, der Dauer der längsten Zubereitung (Zeilen 7–13);
  • Zeilen 39–54: Ein Elternteil startet zwei Kinder, die zehn Sekunden warten. Nach 200 ms [cancelAndJoin()] bricht den Elternteil ab und wartet, bis der Abbruch abgeschlossen ist: Beide Kinder werden mit ihm abgebrochen (Zeilen 14–16). Der [finally]-Block jedes Kindes wird ausgeführt, genau wie beim Verlassen eines Blocks durch eine Ausnahme: Im Abschnitt über den Abbruch werden wir sehen, dass genau das geschieht;
  • Zeilen 56–73: In einem durch [coroutineScope] erstellten Scope wartet ein Kind zehn Sekunden, und sein Geschwisterkind schlägt nach 200 ms fehl. Der Fehler bricht den Scope ab, der wiederum das erste Kind abbricht (Zeile 17), und [coroutineScope] wirft die Ausnahme des fehlgeschlagenen Kindes (Zeile 18), die von einem gewöhnlichen [try / catch] um den Aufruf herum abgefangen wird.

Zwei Funktionen erstellen also einen Scope, mit zwei verschiedenen Verwendungen:

  • [runBlocking] erstellt den Wurzel-Scope eines Programms aus normalem Code, indem es den Thread blockiert;
  • [coroutineScope] erstellt einen Scope innerhalb einer Suspend-Funktion, ohne Threads zu blockieren. Dies ist die Standardmethode, um eine Suspend-Funktion zu schreiben, die mehrere Operationen nebenläufig ausführt: Von außen ist die Nebenläufigkeit nicht sichtbar.

Daraus folgt eine Stilregel: Eine Suspend-Funktion muss ihre gesamte Arbeit abgeschlossen haben, wenn sie die Kontrolle zurückgibt. Eine Funktion, die Coroutinen startet, die sie überdauern sollen, darf keine Suspend-Funktion sein, sondern muss eine Erweiterungsfunktion von [CoroutineScope] sein (wie [launch] selbst): [fun CoroutineScope.monitor(): Job]. Ihre Signatur zeigt somit, dass sie Coroutinen im Scope des Aufrufers startet. Später in diesem Kapitel werden wir sehen, dass die Bibliothek auch Scopes anbietet, deren Kinder voneinander unabhängig sind ([supervisorScope]), und wie man einen Scope erstellt, der für eine Anwendungskomponente spezifisch ist. Am Ende des Kapitels wird die strukturierte Nebenläufigkeit von Kotlin mit der von Java verglichen.

9.5. Sequenzielle und nebenläufige Ausführung

9.5.1. async und awaitAll

Wie das Kaffeebeispiel gezeigt hat, ist ein Aufruf einer Suspend-Funktion sequenziell, und um mehrere Operationen gleichzeitig auszuführen, muss man sie ausdrücklich in Coroutinen starten. Der Zeitpunkt, zu dem eine Operation gestartet wird ([val d = async { operation() }]), und der Zeitpunkt, zu dem auf sie gewartet wird ([d.await()]), können somit getrennt werden, sodass dazwischen andere Operationen gestartet werden können. Das Programm [Async12.kt] vergleicht die beiden Ansätze anhand von Operationen, die eine Sekunde dauern:

// sequentielle und nebenläufige Ausführung von Operationen von einer Sekunde
package async12

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.asCoroutineDispatcher
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import java.util.concurrent.Executors
import kotlin.time.measureTimedValue

fun main() = runBlocking {
    // 1 - nacheinander: jede Operation ist beendet, bevor die nächste beginnt
    val (sequence, duration1) = measureTimedValue {
        val a = readTemperature("Angers")
        val b = readTemperature("Brest")
        val c = readTemperature("Colmar")
        listOf(a, b, c)
    }
    println("1 - in sequence: $sequence in ${duration1.inWholeMilliseconds} ms")

    // 2 - nebenläufig: die drei Operationen werden gestartet und dann abgewartet
    val (concurrent, duration2) = measureTimedValue {
        val a = async { readTemperature("Angers") }
        val b = async { readTemperature("Brest") }
        val c = async { readTemperature("Colmar") }
        listOf(a.await(), b.await(), c.await())
    }
    println("2 - concurrently: $concurrent in ${duration2.inWholeMilliseconds} ms")

    // 3 - eine Liste von Operationen: map { async { … } } dann awaitAll()
    val cities = listOf("Angers", "Brest", "Colmar", "Dijon", "Évry", "Foix")
    val (temperatures, duration3) = measureTimedValue {
        cities.map { city -> async { readTemperature(city) } }.awaitAll()
    }
    println("3 - ${cities.size} cities: $temperatures in ${duration3.inWholeMilliseconds} ms")

    // 4 - eine blockierende Funktion wird an den IO-Dispatcher übergeben
    val (temperatures4, duration4) = measureTimedValue {
        cities.map { city -> async(Dispatchers.IO) { readTemperatureBlocking(city) } }.awaitAll()
    }
    println("4 - ${cities.size} cities (Dispatchers.IO): $temperatures4 in ${duration4.inWholeMilliseconds} ms")

    // 5 - 100 blockierende Operationen auf dem IO-Dispatcher, auf 64 Threads begrenzt
    val (hundredIO, duration5) = measureTimedValue {
        (1..100).map { async(Dispatchers.IO) { readTemperatureBlocking("city$it") } }.awaitAll()
    }
    println("5 - ${hundredIO.size} cities (Dispatchers.IO) in ${duration5.inWholeMilliseconds} ms")

    // 6 - dasselbe auf einem Dispatcher virtueller Threads
    Executors.newVirtualThreadPerTaskExecutor().asCoroutineDispatcher().use { virtuals ->
        val (hundredVirtual, duration6) = measureTimedValue {
            (1..100).map { async(virtuals) { readTemperatureBlocking("city$it") } }.awaitAll()
        }
        println("6 - ${hundredVirtual.size} cities (virtual threads) in ${duration6.inWholeMilliseconds} ms")
    }
}

// simuliert die Abfrage eines entfernten Dienstes, der in einer Sekunde antwortet
suspend fun readTemperature(city: String): Int {
    delay(1000)
    // eine aus dem Namen der Stadt abgeleitete "Temperatur"
    return 10 + city.length
}

// dieselbe Operation, blockierend geschrieben
fun readTemperatureBlocking(city: String): Int {
    Thread.sleep(1000)
    return 10 + city.length
}

Ergebnisse:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=async12.Async12Kt
1 - in sequence: [16, 15, 16] in 3045 ms
2 - concurrently: [16, 15, 16] in 1027 ms
3 - 6 cities: [16, 15, 16, 15, 14, 14] in 1004 ms
4 - 6 cities (Dispatchers.IO): [16, 15, 16, 15, 14, 14] in 1061 ms
5 - 100 cities (Dispatchers.IO) in 2018 ms
6 - 100 cities (virtual threads) in 1026 ms

Kommentare:

  • Zeilen 60–64: die simulierte Operation: eine Verzögerung von einer Sekunde, gefolgt von einer „Temperatur“, die aus der Länge des Städtenamens abgeleitet wird;
  • Zeilen 14–21: Jede Operation wird direkt aufgerufen und ist daher beendet, bevor die nächste beginnt: 3 Sekunden (Zeile 2 der Ergebnisse). Die Funktion [measureTimedValue { … }] aus der Standardbibliothek ([kotlin.time]) führt den Block aus und gibt ein Objekt [TimedValue] zurück, das den Wert des Blocks und die Dauer seiner Ausführung enthält; dies ist eine Datenklasse, die in zwei Variablen zerlegt wird ([val (sequence, duration1) = …], Kapitel 3). Die Dauer ist eine [Duration], bei der [inWholeMilliseconds] die Anzahl der Millisekunden darstellt. Da der Block ein [inline]-Block ist, können darin Suspend-Funktionen aufgerufen werden;
  • Zeilen 23–28: Die drei Operationen werden mit [async] in drei Coroutinen gestartet und dann abgewartet. Sie laufen gleichzeitig: eine Sekunde statt drei (Zeile 3). Die Reihenfolge der [await]-Aufrufe ist unerheblich: Der erste wartet auf das Ende der ersten Operation, während die anderen ihre bereits oder fast beendet vorfinden;
  • Zeilen 32–35: der Fall einer Liste von Operationen. [cities.map { city -> async { … } }] startet eine Coroutine pro Stadt und erzeugt eine Liste von [Deferred<Int>]; die Erweiterungsfunktion [awaitAll()] für eine Collection von [Deferred] wartet auf alle und gibt die Liste ihrer Ergebnisse zurück, in der Reihenfolge der Operationen (nicht in der Reihenfolge, in der sie beendet wurden). Die sechs Operationen zusammen dauern eine Sekunde (Zeile 4). Verglichen mit der Java-Version ([allOf] auf einem Array von [CompletableFuture], gefolgt von einer Continuation, die die Ergebnisse mit [join] einsammelt) ist der Code unkompliziert;
  • Zeilen 39–43: dasselbe mit einer blockierenden Funktion ([readTemperatureBlocking], Zeilen 67–69), ausgeführt auf [Dispatchers.IO]: Jede Operation blockiert einen Thread dieses Dispatchers; alle sechs zusammen dauern eine Sekunde (Zeile 5);
  • Zeilen 45–49: Bei 100 blockierenden Operationen wird die Grenze von 64 Threads von [Dispatchers.IO] deutlich: 64 Operationen, dann die restlichen 36, insgesamt zwei Sekunden (Zeile 6). Dies ist dieselbe Thread-Starvation, die wir bereits beim Pool mit 10 Threads in [Async01.kt] erlebt haben, nur in größerem Maßstab;
  • Zeilen 51–56: dieselben 100 blockierenden Operationen auf einem Dispatcher für virtuelle Threads: eine Sekunde (Zeile 7), da blockierte virtuelle Threads keine System-Threads belegen. Der Parameter [virtuals] von [use] ist der Dispatcher, der als Kontext an [async] übergeben wird.

Die letzten beiden Schritte zeigen, wie sich Coroutinen und virtuelle Threads ergänzen: Coroutinen für Code, der mit Suspend-Funktionen geschrieben ist, und virtuelle Threads – über einen Dispatcher –, um eine große Menge aus Java geerbten blockierenden Codes aus Coroutinen heraus auszuführen.

9.5.2. Die zuerst abgeschlossene Operation: select

Die Funktion [select] (Paket [kotlinx.coroutines.selects]) suspendiert die Coroutine, bis eines von mehreren Ereignissen eintritt, und gibt den diesem Ereignis zugeordneten Wert zurück. Jedes mögliche Ereignis ist eine Klausel: [onAwait] für das Ende eines [Deferred] (die Klausel erhält dessen Ergebnis), [onJoin] für das Ende eines [Job], [onReceive] für das Eintreffen eines Werts in einem Channel … Es ist das Äquivalent zu [CompletableFuture.anyOf] mit einem typisierten Ergebnis. Das Programm [Async13.kt] verwendet es auf drei Arten:

// select: auf die erste abgeschlossene Operation reagieren
package async13

import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.delay
import kotlinx.coroutines.joinAll
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.selects.select

var start = System.nanoTime()

fun main() = runBlocking {
    start = System.nanoTime()
    // 1 - drei Mirror-Server werden abgefragt und die erste Antwort wird behalten
    val requests = listOf(
        async { query("mirror-paris", 800) },
        async { query("mirror-lyon", 300) },
        async { query("mirror-lille", 600) })
    // select setzt die Coroutine aus, bis eine der Klauseln gewählt wird
    val first = select {
        requests.forEach { request -> request.onAwait { answer -> answer } }
    }
    display("1 - first answer: $first")
    // die anderen Anfragen laufen weiter: hier wird auf sie gewartet, um ihre Antworten zu sehen
    display("1 - all the answers: ${requests.awaitAll()}")

    // 2 - dasselbe, aber die überflüssig gewordenen Anfragen werden abgebrochen
    start = System.nanoTime()
    val requests2 = listOf(
        async { query("mirror-paris", 800) },
        async { query("mirror-lyon", 300) },
        async { query("mirror-lille", 600) })
    val first2 = select {
        requests2.forEach { request -> request.onAwait { answer -> answer } }
    }
    requests2.forEach { it.cancel() }
    // wir warten auf das Ende der abgebrochenen Anfragen
    requests2.joinAll()
    display("2 - first answer: $first2, the other requests are cancelled")

    // 3 - eine zeitlich begrenzte Operation: sie "wettläuft" gegen ein delay
    start = System.nanoTime()
    val slow = async { query("slow-server", 2000) }
    val timer = launch { delay(500) }
    val answer: String? = select {
        slow.onAwait { it }
        timer.onJoin { null }
    }
    if (answer != null) {
        display("3 - answer obtained in time: $answer")
    } else {
        display("3 - the slow server did not answer within 500 ms: it is cancelled")
        slow.cancel()
    }
    slow.join()
    display("3 - end of the program")
}

// simuliert einen Server, der nach [duration] Millisekunden antwortet
suspend fun query(server: String, duration: Long): String {
    try {
        delay(duration)
        return "$server ($duration ms)"
    } catch (e: CancellationException) {
        // die Coroutine wurde während ihres Wartens abgebrochen: dies wird gemeldet, dann wird die Exception erneut geworfen
        display("  $server: request cancelled (${e.javaClass.simpleName})")
        throw e
    }
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) = println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=async13.Async13Kt
  374 ms : 1 - first answer: mirror-lyon (300 ms)
  854 ms : 1 - all the answers: [mirror-paris (800 ms), mirror-lyon (300 ms), mirror-lille (600 ms)]
  325 ms :   mirror-paris: request cancelled (JobCancellationException)
  329 ms :   mirror-lille: request cancelled (JobCancellationException)
  340 ms : 2 - first answer: mirror-lyon (300 ms), the other requests are cancelled
  524 ms : 3 - the slow server did not answer within 500 ms: it is cancelled
  524 ms :   slow-server: request cancelled (JobCancellationException)
  525 ms : 3 - end of the program

Kommentare:

  • Zeilen 62–70: Der simulierte Server antwortet nach der angegebenen Zeit. Wird die Coroutine, die ihn abfragt, während des Wartens abgebrochen, wirft [delay] eine [CancellationException]: Wir fangen sie ab, um den Abbruch zu signalisieren, und werfen sie dann erneut (im Abschnitt über den Abbruch werden wir sehen, warum dies unerlässlich ist). [kotlinx.coroutines.CancellationException] ist ein Alias für die Klasse [java.util.concurrent.CancellationException] des JDK; die tatsächlich geworfene Exception gehört zu einer davon abgeleiteten internen Klasse der Bibliothek, [JobCancellationException];
  • Zeilen 17–21: Drei Spiegelserver werden abgefragt; sie enthalten alle dieselben Informationen und antworten unterschiedlich schnell, jeder in einer Coroutine;
  • Zeilen 23–26: Der [select]-Block deklariert für jede Abfrage eine [onAwait]-Klausel; das Lambda jeder Klausel erhält das Ergebnis der Abfrage und gibt den Wert von [select] zurück. Klauseln können in einer Schleife deklariert werden, wie hier gezeigt. Das zuerst abgeschlossene [Deferred] setzt sich durch: Die erste Antwort trifft nach etwas mehr als 300 ms ein (Zeile 2 der Ergebnisse; die erste Verwendung von [select] lädt einige weitere Klassen); ihr Typ ist [String], ohne Typumwandlung, anders als bei [anyOf], das ein [Object] zurückgibt;
  • Zeile 28: [select] hat die anderen Abfragen nicht gestoppt, die weiterlaufen: [awaitAll()] wartet darauf, dass sie alle Antworten anzeigen (Zeile 3);
  • Zeilen 30–42: In den meisten Fällen sind die anderen Anfragen überflüssig geworden. Anders als ein [CompletableFuture] kann eine Coroutine tatsächlich beendet werden: [cancel()] bricht jede Anfrage ab (der Abbruch einer bereits abgeschlossenen Anfrage hat keine Wirkung), und [joinAll()] wartet darauf, dass die abgebrochenen Anfragen beendet sind. Die Zeilen 4 und 5 der Ergebnisse zeigen, dass die beiden ausstehenden Anfragen während des Wartens unterbrochen wurden; sie verbrauchen keine Ressourcen mehr;
  • Zeilen 44–59: ein klassischer Anwendungsfall: ein Wettlauf gegen ein Zeitlimit. Die Klausel [onJoin] des [Job] [timer], der 500 ms wartet, gibt [null] zurück; wenn er gewinnt, hat die Operation zu lange gedauert und wird abgebrochen (Zeilen 7–9). Der Typ von [answer] ist [String?]: [select] gibt entweder die Antwortzeichenfolge oder [null] zurück. Kotlinx.coroutines bietet für diesen Fall einen einfacheren Weg: die Funktion [withTimeoutOrNull], die später beschrieben wird.

9.5.3. Ergebnisse nach ihrem Eintreffen verarbeiten

Oft möchte man die Ergebnisse mehrerer Operationen verarbeiten, sobald sie vorliegen, ohne auf die langsamste zu warten. Der Java-Kurs tat dies auf zwei Arten: indem an jedes [CompletableFuture] eine Continuation angehängt wurde oder indem die Aufgaben an einen [ExecutorCompletionService] delegiert wurden, der die [Future] in der Reihenfolge ihres Abschlusses liefert. Mit Coroutinen gibt es ebenfalls zwei Möglichkeiten: das Ergebnis in der Coroutine zu verwenden, die es erzeugt hat, oder die Ergebnisse über einen Channel ([Channel]) weiterzugeben, eine Warteschlange zwischen Coroutinen. Das Programm [Async14.kt] verarbeitet fünf „Dateien“, von denen jede zwischen 100 und 900 ms Verarbeitungszeit benötigt, mit beiden Methoden:

// Verarbeitung der Ergebnisse in der Reihenfolge, in der die Operationen enden
package async14

import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

var start = 0L
val durations = listOf(900L, 300L, 700L, 100L, 500L)

fun main() = runBlocking {
    // 1 - eine Coroutine pro Datei: jede verwendet ihr Ergebnis, sobald sie es hat
    start = System.nanoTime()
    coroutineScope {
        durations.forEachIndexed { i, duration ->
            launch { display(process("file$i.txt", duration)) }
        }
    } // coroutineScope wartet auf das Ende der fünf Coroutinen
    display("1 - all the files have been processed")

    // 2 - die Coroutinen senden ihre Ergebnisse in einen Channel, eine einzige Coroutine verwendet sie
    start = System.nanoTime()
    val results = Channel<String>()
    durations.forEachIndexed { i, duration ->
        launch { results.send(process("file$i.txt", duration)) }
    }
    // receive() setzt die Coroutine aus, bis das nächste Ergebnis eintrifft
    repeat(durations.size) {
        display(results.receive())
    }
    display("2 - all the files have been processed")
}

// simuliert die Verarbeitung einer Datei, die [duration] Millisekunden dauert
suspend fun process(file: String, duration: Long): String {
    delay(duration)
    return "$file processed in $duration ms"
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) = println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async14.Async14Kt
  133 ms : file3.txt processed in 100 ms
  326 ms : file1.txt processed in 300 ms
  525 ms : file4.txt processed in 500 ms
  725 ms : file2.txt processed in 700 ms
  922 ms : file0.txt processed in 900 ms
  923 ms : 1 - all the files have been processed
  176 ms : file3.txt processed in 100 ms
  373 ms : file1.txt processed in 300 ms
  573 ms : file4.txt processed in 500 ms
  775 ms : file2.txt processed in 700 ms
  976 ms : file0.txt processed in 900 ms
  976 ms : 2 - all the files have been processed

Kommentare:

  • Zeilen 36–39: die simulierte Verarbeitung einer Datei, die die angegebene Zeit benötigt;
  • Zeilen 14–21: Jede Verarbeitung wird in einer eigenen Coroutine gestartet, die ihr Ergebnis anzeigt, sobald es vorliegt: Datei 3 (100 ms) wird zuerst angezeigt, Datei 0 (900 ms) zuletzt (Zeilen 2–6 der Ergebnisse). Dies entspricht der an jedes [CompletableFuture] angehängten Continuation, aber Verarbeitung und Anzeige werden nacheinander geschrieben: [display(process(...))]. Der [coroutineScope]-Block wartet, bis alle fünf Coroutinen beendet sind; er ersetzt das [allOf] im Java-Programm. Die Funktion [forEachIndexed] durchläuft die Liste [durations] und liefert dabei sowohl den Index als auch das Element;
  • Zeilen 23–33: Die fünf Coroutinen senden ihre Ergebnisse an einen Channel ([Channel<String>]) mithilfe der Suspend-Funktion [send]; die Haupt-Coroutine empfängt sie einzeln mit der Suspend-Funktion [receive()], die auf das nächste verfügbare Ergebnis wartet. Sie empfängt sie also in der Reihenfolge, in der die Verarbeitungen abgeschlossen werden (Zeilen 8–12): Dies entspricht dem [CompletionService] von Java, ohne Threads zu blockieren. Ein durch [Channel<String>()] erzeugter Channel hat keinen Puffer: Jedes [send] wartet darauf, dass eine Coroutine den Wert empfängt (dies ist ein „Rendezvous“). Channels werden später in diesem Kapitel ausführlich besprochen;
  • In beiden Fällen dauert der gesamte Vorgang 900 ms – die Dauer der längsten Operation – und jedes Ergebnis wird so früh wie möglich verarbeitet. Der erste Ansatz eignet sich, wenn jedes Ergebnis unabhängig von den anderen verarbeitet werden kann; der zweite eignet sich, wenn ein einziger Codeabschnitt alle empfangen muss, zum Beispiel um sie zu aggregieren oder in einer grafischen Benutzeroberfläche anzuzeigen.

9.6. Ausnahmen in Coroutinen

9.6.1. try/catch und Weitergabe in der strukturierten Nebenläufigkeit

Bei [CompletableFuture] wird eine Ausnahme nicht an den Code zurückgeworfen, der die Operation gestartet hat: Sie wird in [CompletableFuture] gespeichert, wird entlang der Continuation-Kette weitergegeben und mit dafür vorgesehenen Methoden behandelt ([exceptionally], [handle], [whenComplete]). Bei Suspend-Funktionen ist die Sache viel einfacher: Eine Suspend-Funktion wirft Ausnahmen genau wie eine gewöhnliche Funktion, und sie werden mit [try / catch] abgefangen, auch wenn die Ausnahme nach einer Suspendierung in einem anderen Thread geworfen wurde. Es gibt nur eine neue Sache zu lernen: was geschieht, wenn eine Coroutine, die von [launch] oder [async] gestartet wurde, fehlschlägt. Das Programm [Async15.kt] untersucht die verschiedenen Fälle:

// Exceptions in Coroutinen: gewöhnliches try / catch, Propagierung in der strukturierten Nebenläufigkeit
package async15

import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.supervisorScope

fun main() = runBlocking<Unit> {
    // 1 - eine suspendierende Funktion wirft ihre Exceptions wie eine gewöhnliche Funktion
    try {
        val value = readValue("twelve")
        println("value = $value")
    } catch (e: NumberFormatException) {
        println("1 - readValue throws ${name(e)} : ${e.message}")
    }

    // 2 - ein Ersatzwert im Fehlerfall: try ist ein Ausdruck
    val value = try {
        readValue("thirteen")
    } catch (_: NumberFormatException) {
        -1
    }
    println("2 - replacement value: $value")

    // 3 - catch behandelt den Fehler, finally läuft in jedem Fall
    for (text in listOf("14", "fifteen")) {
        val report = try {
            "value ${readValue(text)}"
        } catch (e: NumberFormatException) {
            "failure, ${name(e)}"
        } finally {
            println("3 - finally: the reading of [$text] is finished")
        }
        println("3 - report: $report")
    }

    // 4 - ein Parameterfehler nimmt denselben Weg
    try {
        readValue(" ")
    } catch (e: IllegalArgumentException) {
        println("4 - readValue throws ${name(e)} : ${e.message}")
    }

    // 5 - mehrere Operationen in coroutineScope: der erste Fehlschlag bricht die anderen ab
    val texts = listOf("1", "two", "3", "four")
    val readings = mutableListOf<Deferred<Int>>()
    try {
        coroutineScope {
            texts.forEach { text -> readings += async { readValue(text) } }
            println("5 - results: ${readings.awaitAll()}")
        }
    } catch (e: NumberFormatException) {
        println("5 - coroutineScope throws ${name(e)} : ${e.message}")
    }
    // jede Operation hat ihr Ergebnis oder ihre Exception behalten
    readings.forEachIndexed { i, reading -> println("      [${texts[i]}] : ${outcome(reading)}") }

    // 6 - das Abfangen der Exception von await() genügt nicht: der Fehlschlag des Kindes hat die Eltern bereits erreicht
    try {
        coroutineScope {
            val reading = async { readValue("six") }
            val result = try {
                reading.await()
            } catch (e: NumberFormatException) {
                println("6 - await() threw ${name(e)}, caught")
                -1
            }
            println("6 - the code continues with $result…")
        }
    } catch (e: NumberFormatException) {
        println("6 - … but coroutineScope rethrows ${name(e)} : ${e.message}")
    }

    // 7 - supervisorScope: der Fehlschlag eines Kindes betrifft nur dieses Kind
    supervisorScope {
        val readings7 = texts.map { text -> async { readValue(text) } }
        readings7.forEachIndexed { i, reading -> println("7 - [${texts[i]}] : ${outcome(reading)}") }
    }
}

// eine Operation, die fehlschlägt, wenn der String keine ganze Zahl ist; sie dauert 100 ms pro Zeichen
suspend fun readValue(text: String): Int {
    // Überprüfung des Parameters
    require(text.isNotBlank()) { "the text must not be empty" }
    delay(100L * text.length)
    return text.toInt()
}

// das Resultat einer Operation: ihr Ergebnis, ihre Exception oder ihr Abbruch
suspend fun outcome(reading: Deferred<Int>): String = try {
    "success, result = ${reading.await()}"
} catch (e: CancellationException) {
    "cancelled (${name(e)})"
} catch (e: NumberFormatException) {
    "failure, ${name(e)} : ${e.message}"
}

// der einfache Name der Klasse einer Exception
fun name(e: Throwable): String = e.javaClass.simpleName

Ergebnisse:

> gradlew -q run -Pmain=async15.Async15Kt
1 - readValue throws NumberFormatException : For input string: "twelve"
2 - replacement value: -1
3 - finally: the reading of [14] is finished
3 - report: value 14
3 - finally: the reading of [fifteen] is finished
3 - report: failure, NumberFormatException
4 - readValue throws IllegalArgumentException : the text must not be empty
5 - coroutineScope throws NumberFormatException : For input string: "two"
      [1] : success, result = 1
      [two] : failure, NumberFormatException : For input string: "two"
      [3] : success, result = 3
      [four] : cancelled (JobCancellationException)
6 - await() threw NumberFormatException, caught
6 - the code continues with -1…
6 - … but coroutineScope rethrows NumberFormatException : For input string: "six"
7 - [1] : success, result = 1
7 - [two] : failure, NumberFormatException : For input string: "two"
7 - [3] : success, result = 3
7 - [four] : failure, NumberFormatException : For input string: "four"

Kommentare:

  • Zeilen 86–91: die getestete Funktion. Sie prüft zunächst ihren Parameter mit [require] (Kapitel 3), das eine [IllegalArgumentException] wirft, wenn die Bedingung falsch ist. Dann wartet sie 100 ms pro Zeichen des Textes und wandelt den gesamten Text um, was eine [NumberFormatException] auslöst, wenn er keine Zahl ist;
  • Zeilen 14–19: der Normalfall. Die nach der Suspendierung von [toInt()] geworfene Ausnahme wird vom [try / catch] des Aufrufers unverändert abgefangen: Weder [CompletionException] noch [ExecutionException] noch die Methode [cause] wird benötigt, um zur ursprünglichen Ausnahme zurückzugelangen (Zeile 2 der Ergebnisse);
  • Zeilen 22–28: [try] ist in Kotlin ein Ausdruck: Sein Wert ist der des [try]-Blocks oder der des [catch]-Blocks. Dies entspricht der Methode [exceptionally] von [CompletableFuture] (Zeile 3). Der Parameter [_] zeigt an, dass die Ausnahme nicht verwendet wird;
  • Zeilen 30–39: [catch] wandelt einen Fehler in ein Ergebnis um (das Äquivalent zu [handle]), [finally] wird in allen Fällen ausgeführt (Äquivalent zu [whenComplete]): Zeilen 4 bis 7. Es werden die üblichen Werkzeuge verwendet;
  • Zeilen 42–46: In Java konnte eine Methode, die ein [CompletableFuture] zurückgibt, auf zwei Arten fehlschlagen – indem sie beim Aufruf eine Ausnahme wirft (Parametervalidierung) oder indem sie eine fehlgeschlagene Operation zurückgibt –, und der Aufrufer musste auf beides vorbereitet sein. Eine suspendierbare Funktion kann nur auf eine Weise fehlschlagen: indem sie eine Ausnahme wirft (Zeile 8);
  • Zeilen 49–58: Vier Lesevorgänge werden mit *[async] innerhalb eines *[coroutineScope]*-Scopes gestartet und mit *[awaitAll()]* abgewartet. Der Lesevorgang für ["two"] schlägt nach 300 ms fehl. Nach den Regeln der strukturierten Nebenläufigkeit bricht der Fehlschlag eines Kindes seinen Elternteil, den Scope und damit alle seine anderen Kinder ab: Der Lesevorgang für ["four"], der 400 ms dauern sollte, wird abgebrochen. [coroutineScope] wirft dann die Ausnahme des fehlgeschlagenen Kindes (Zeile 9). Zeile 55 wird nie ausgeführt: [awaitAll()]* wirft die Ausnahme ebenfalls;
  • Zeile 61: Jedes [Deferred] hat sein Ergebnis behalten, das die Funktion [outcome] (Zeilen 94–100) durch den Aufruf von [await()] untersucht: Bei einer abgeschlossenen Operation gibt [await()] sofort ihr Ergebnis zurück oder wirft ihre Ausnahme, und bei einer abgebrochenen Operation wirft es eine [CancellationException]. Die Zeilen 10 bis 13 der Ergebnisse zeigen zwei erfolgreiche Operationen (["1"] und ["3"], die vor dem Fehler abgeschlossen wurden), den Fehler und den Abbruch von ["four"]. Dies ist in den meisten Fällen das gewünschte Verhalten: Schlägt eine der für ein Ergebnis erforderlichen Operationen fehl, kann das Ergebnis nicht erzeugt werden, und es hat keinen Sinn, mit den anderen fortzufahren;
  • Zeilen 63–76: eine klassische Falle. Die von [await()] geworfene Ausnahme wird abgefangen und durch einen Standardwert ersetzt, und der Code läuft weiter (Zeilen 14 und 15); aber der Fehlschlag des Kindes wurde bereits an seinen Elternteil weitergegeben, der abgebrochen wurde: Am Ende seines Blocks wirft [coroutineScope] die Ausnahme trotzdem (Zeile 16). Um zu verhindern, dass ein Fehlschlag den Elternteil beeinträchtigt, müssen Sie ihn entweder in der fehlschlagenden Coroutine abfangen ([async { try { readValue("six") } catch (e: NumberFormatException) { -1 } }]) oder einen Supervisor-Scope verwenden;
  • Zeilen 79–82: [supervisorScope { … }] erstellt einen Supervisor-Scope: Wie [coroutineScope] wartet er auf alle seine Kinder und bricht sie ab, wenn er selbst abgebrochen wird, aber der Fehlschlag eines Kindes betrifft nur dieses selbst: Er bricht weder den Scope noch die anderen Kinder ab. Jeder Lesevorgang läuft bis zum Ende, und der Aufrufer untersucht das Ergebnis jedes einzelnen (Zeilen 17–20): Diesmal ist der Lesevorgang für ["four"] fehlgeschlagen, statt abgebrochen zu werden. Dies ist erforderlich, wenn die Operationen unabhängig sind: zum Beispiel die Anzeige der Temperaturen von sechs Städten, auch wenn eine davon nicht antwortet.

Der Java-Kurs kam zu dem Schluss, dass Ausnahmen in virtuellen Threads wie in gewöhnlichem Code behandelt werden, außer an der Grenze zwischen zwei Threads; dies gilt auch für Coroutinen, und die strukturierte Nebenläufigkeit löst das Grenzproblem: Der Fehlschlag einer Kind-Coroutine wird automatisch an die Eltern-Coroutine zurückgereicht.

9.6.2. Die vergessenen Coroutinen, CoroutineExceptionHandler, SupervisorJob und GlobalScope

Der Java-Kurs hat gezeigt, dass eine Ausnahme aus einer Operation, auf die niemand wartete, verloren ging, ganz ohne Meldung. In der strukturierten Nebenläufigkeit kann eine Coroutine nicht wirklich vergessen werden: Ihr Scope wartet auf sie, und in einem gewöhnlichen Scope wird ihr Fehlschlag an den Elternteil weitergegeben. Ein Supervisor-Scope bricht den Elternteil jedoch nicht ab, und es gibt Möglichkeiten, eine Coroutine außerhalb jeder Struktur zu starten: Was geschieht in diesem Fall mit den Ausnahmen? Das Programm [Async16.kt] zeigt dies:

// Coroutinen, auf deren Ergebnis niemand wartet: wohin gehen ihre Exceptions?
package async16

import kotlinx.coroutines.CoroutineExceptionHandler
import kotlinx.coroutines.CoroutineName
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.async
import kotlinx.coroutines.cancel
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.supervisorScope

// der Handler für die Exceptions, die keine Coroutine abgefangen hat
val handler = CoroutineExceptionHandler { context, e ->
    println("CoroutineExceptionHandler: ${e.message} (coroutine ${context[CoroutineName]?.name})")
}

@OptIn(DelicateCoroutinesApi::class)
fun main() {
    // der Handler für die nicht abgefangenen Exceptions der Threads
    Thread.setDefaultUncaughtExceptionHandler { thread, e ->
        println("uncaught exception in [${thread.name}] : ${e.message}")
    }
    runBlocking {
        supervisorScope {
            // 1 - ein abgewartetes Deferred: seine Exception wird abgefangen
            val a = async { save("a") }
            try {
                a.await()
            } catch (e: IllegalStateException) {
                println("1 - awaited Deferred: exception caught: ${e.message}")
            }

            // 2 - ein Deferred, auf das niemand wartet: seine Exception bleibt im Objekt
            async { save("b") }
            println("2 - forgotten Deferred: the coroutine is launched")

            // 3 - ein Job hat kein Ergebnis, in dem er die Exception speichern könnte: sie geht an den Handler des Threads
            launch { save("c") }
            println("3 - launch without a handler: the coroutine is launched")

            // 4 - … oder an den CoroutineExceptionHandler im Kontext der Coroutine
            launch(handler + CoroutineName("saver-d")) { save("d") }
            println("4 - launch with a CoroutineExceptionHandler: the coroutine is launched")

            // 5 - starten ohne zu warten, aber den Fehlschlag selbst behandeln
            launch {
                try {
                    save("e")
                } catch (e: IllegalStateException) {
                    println("5 - failure handled by the coroutine itself: ${e.message}")
                }
            }

            // das Programm setzt seine Arbeit fort…
            for (i in 1..3) {
                delay(100)
                println("the program is working ($i)")
            }
        } // supervisorScope wartet auf alle seine Kinder, auch die "vergessenen"

        // 6 - ein Scope speziell für eine Komponente der Anwendung, mit einem SupervisorJob
        val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default + handler)
        scope.launch(CoroutineName("saver-f")) { save("f") }
        scope.launch(CoroutineName("counter")) {
            repeat(3) {
                delay(100)
                println("6 - the counter continues its work despite the failure of its sibling ($it)")
            }
        }
        delay(400)
        // das Ende der Komponente: alles, was ihr Scope gestartet hat, wird abgebrochen
        scope.cancel()

        // 7 - GlobalScope: eine außerhalb jeder Struktur gestartete Coroutine, auf die niemand wartet
        GlobalScope.launch { save("g") }
        GlobalScope.launch {
            delay(1000)
            println("7 - this message will never be displayed")
        }
        delay(300)
    }
    println("normal end of the program")
}

// eine Operation, die nach 200 ms fehlschlägt
suspend fun save(data: String) {
    delay(200)
    throw IllegalStateException("failure saving [$data]")
}

Ergebnisse:

> gradlew -q run -Pmain=async16.Async16Kt
1 - awaited Deferred: exception caught: failure saving [a]
2 - forgotten Deferred: the coroutine is launched
3 - launch without a handler: the coroutine is launched
4 - launch with a CoroutineExceptionHandler: the coroutine is launched
the program is working (1)
uncaught exception in [main] : failure saving [c]
CoroutineExceptionHandler: failure saving [d] (coroutine saver-d)
5 - failure handled by the coroutine itself: failure saving [e]
the program is working (2)
the program is working (3)
6 - the counter continues its work despite the failure of its sibling (0)
CoroutineExceptionHandler: failure saving [f] (coroutine saver-f)
6 - the counter continues its work despite the failure of its sibling (1)
6 - the counter continues its work despite the failure of its sibling (2)
uncaught exception in [DefaultDispatcher-worker-1] : failure saving [g]
normal end of the program

Kommentare:

  • Zeilen 91–94: die von allen Fällen verwendete Operation, die nach 200 ms fehlschlägt;
  • Zeilen 26–27: Wie im Java-Programm richten wir den Handler ein, der aufgerufen wird, wenn eine Ausnahme von keinem Code in einem Thread abgefangen wird. Ohne ihn gibt die JVM den Stacktrace der Ausnahme auf der Fehlerausgabe aus;
  • Zeilen 18–20: Ein *[CoroutineExceptionHandler] ist ein Kontextelement, das Ausnahmen empfängt, die keine Coroutine behandelt hat; es wird mit einem Lambda erstellt, das den Kontext der fehlgeschlagenen Coroutine und die Ausnahme entgegennimmt. [context[CoroutineName]] gibt das Element [CoroutineName] aus dem Kontext zurück, oder [null]* , falls keines existiert: Der Kontext wird als assoziatives Array verwendet, das nach dem Typ der Elemente indiziert ist;
  • Alle Coroutinen der Fälle 1 bis 5 werden in einem *[supervisorScope]* gestartet: Der Fehlschlag einer Coroutine wird nicht an den Elternteil weitergegeben; daher muss sich jemand anderes darum kümmern;
  • Zeilen 31–36: Auf die Operation wird mit [await()] gewartet; ihre Ausnahme wird normal abgefangen (Zeile 2 der Ergebnisse);
  • Zeilen 39–41: eine von [async] gestartete Coroutine, für die niemand [await()] aufruft. Ihre Ausnahme wird in [Deferred] gespeichert, das ignoriert wird: Sie geht verloren, genau wie die eines vergessenen [CompletableFuture], und nichts zeigt sie an. Eine mit [async] gestartete Coroutine ist dafür gedacht, abgewartet zu werden; wird ihr Ergebnis nicht benötigt, verwendet man [launch];
  • Zeilen 43–45: Eine von [launch] gestartete Coroutine hat kein Ergebnis, in dem sie ihre Ausnahme speichern könnte. Wenn ihr Elternteil sie nicht behandelt (wie es in einem Supervisor-Scope der Fall ist), wird die Ausnahme an den [CoroutineExceptionHandler] des Kontexts weitergegeben und, falls es keinen gibt, an den Handler für nicht abgefangene Ausnahmen des Threads, der die Coroutine ausgeführt hat, hier [main] (Zeile 7). Der Thread wird jedoch nicht gestoppt: Er führt die anderen Coroutinen weiter aus;
  • Zeilen 47–49: dieselbe Coroutine mit einem [CoroutineExceptionHandler] in ihrem Kontext: Dieser empfängt die Ausnahme (Zeile 8);
  • Zeilen 51–56: der beste Weg, eine Operation zu starten, ohne auf ihr Ergebnis zu warten: Die Coroutine behandelt ihren eigenen Fehlschlag mit einem [try / catch] (Zeile 9);
  • Zeilen 60–65: Das Programm setzt seine Arbeit fort; am Ende des Blocks wartet [supervisorScope] auf alle seine Kinder, auch auf die, die wir „vergessen“ glaubten;
  • Zeilen 67–78: Eine Anwendungskomponente (ein Bildschirm, ein Service, eine Verbindung), die Coroutinen startet, die so lange bestehen sollen wie die Komponente selbst – und nicht nur für die Dauer eines Funktionsaufrufs –, benötigt einen eigenen Scope. Er wird mit der Funktion [CoroutineScope(context)] erstellt, normalerweise zusammen mit einem [SupervisorJob()], einem *[Job]*, bei dem der Fehlschlag eines Kindes die anderen nicht beendet (das Äquivalent zu *[supervisorScope] für einen auf diese Weise erstellten Scope), einem Dispatcher und einem Exception-Handler. Die von [scope.launch { … }] gestarteten Coroutinen sind Kinder des [SupervisorJob]: Der Fehlschlag von [saver-f], der an den Handler übergeben wird (Zeile 13), hindert [counter] nicht daran, seine Arbeit fortzusetzen (Zeilen 12–15). Wenn die Komponente verschwindet, bricht [scope.cancel()] alles ab, was der Scope gestartet hat: Keine Coroutine überlebt ihre Komponente. So arbeiten die Scopes der Frameworks, etwa [viewModelScope] und [lifecycleScope]* unter Android;
  • Zeilen 80–86: [GlobalScope] ist ein globaler Scope ohne [Job], der während der gesamten Lebensdauer des Programms existiert. Eine von [GlobalScope.launch] gestartete Coroutine hat keinen Elternteil: Niemand wartet auf sie, niemand bricht sie ab, und ihre Ausnahme wird an den Handler des Threads weitergegeben, der sie ausgeführt hat (hier ein Thread von [Dispatchers.Default], dem Standard-Dispatcher von [GlobalScope]: Zeile 16). Die zweite Coroutine, die nach einer Sekunde eine Meldung anzeigen sollte, wird schlicht aufgegeben: [runBlocking] wartet nicht auf sie, und das Programm endet ohne sie (Zeile 17);
  • Zeile 23: [GlobalScope] ist mit [@DelicateCoroutinesApi] annotiert: Seine Verwendung löst eine Compiler-Warnung aus, die in unserem Projekt mit der Option [allWarningsAsErrors] ein Fehler ist:
warning: this is a delicate API and its use requires care. Make sure you fully read and understand documentation of the declaration that is marked as a delicate API.
  • Die Annotation [@OptIn(DelicateCoroutinesApi::class)] an der Funktion teilt dem Compiler mit, dass wir wissen, was wir tun, und lässt die Warnung verschwinden. Dieser „Opt-in“-Mechanismus wird von Kotlin-Bibliotheken verwendet, um heikle oder noch experimentelle APIs zu kennzeichnen.

Die Regel ist dieselbe wie in Java, aber die strukturierte Nebenläufigkeit macht sie nahezu automatisch: Jede Coroutine muss zu einem Scope gehören, der auf sie wartet, und ihr Fehlschlag muss behandelt werden – entweder von der Coroutine selbst, von ihrem Elternteil oder von einem [CoroutineExceptionHandler]. Wir vermeiden [GlobalScope], außer für seltene Coroutinen, die wirklich so lange leben müssen wie das Programm; stattdessen erstellen wir pro Komponente einen Scope, den wir am Ende ihrer Lebensdauer zerstören.

9.7. Abbruch und Timeouts

9.7.1. Kooperativer Abbruch

Eine lang laufende Operation muss abgebrochen werden können: Der Benutzer hat auf [Cancel] geklickt, ein Server-Client hat die Verbindung getrennt, ein Anwendungsfenster wurde geschlossen, oder ein Timeout wurde überschritten. Java verwendet dafür die Thread-Unterbrechung: [interrupt()] setzt ein Flag; blockierende Wartevorgänge werden unterbrochen, indem [InterruptedException] geworfen wird; und eine Berechnung muss das Flag selbst prüfen. Der Java-Kurs wies auch auf eine Falle hin: Die Methode [cancel] eines [CompletableFuture] unterbricht nichts, da ein [CompletableFuture] nicht weiß, welcher Thread für es arbeitet.

Coroutinen haben ihren eigenen Mechanismus, der ebenfalls kooperativ, aber in die Bibliothek integriert ist:

  • Die Methode [cancel()] eines [Job] (oder eines [Deferred]) versetzt diesen in den Zustand „Abbruch läuft“; sie beendet die Coroutine nicht gewaltsam und lässt den Aufrufer auch nicht warten. [join()] wartet dann auf das Ende der Coroutine; [cancelAndJoin()] tut beides;
  • Ist die Coroutine in einer der Suspend-Funktionen von kotlinx.coroutines suspendiert ([delay], [await], [join], [receive], [withContext]…), setzt diese Funktion die Coroutine sofort fort, indem sie eine [CancellationException] auslöst. Dasselbe gilt, wenn die Coroutine eine dieser Funktionen aufruft, während sie bereits abgebrochen ist. Alle diese Funktionen gelten als abbrechbar;
  • Die Ausnahme wandert wie eine gewöhnliche Ausnahme den Aufrufstapel hinauf und führt dabei die [finally]-Blöcke und die [use]-Funktionen aus, wodurch die Ressourcen sauber freigegeben werden. Oben in der Coroutine angekommen, beendet sie diese im Zustand „abgebrochen“; dies ist kein Fehlschlag: Eine [CancellationException] wird nie an den Elternteil oder an Exception-Handler weitergegeben;
  • Eine Coroutine, die Berechnungen durchführt, ohne je eine Suspend-Funktion aufzurufen, ist davon nicht betroffen: Sie muss ihren Zustand selbst prüfen, mit [isActive] (true, solange sie nicht abgebrochen ist), [ensureActive()] (das eine [CancellationException] auslöst, wenn sie abgebrochen ist) oder [yield()] (das den Thread anderen Coroutinen überlässt und dabei auf Abbruch prüft);
  • Der Abbruch eines [Job] bricht seine Kinder ab, wie wir bei der strukturierten Nebenläufigkeit gesehen haben.

Das Programm [Async17.kt] bricht einen simulierten Download und eine simulierte Berechnung auf mehrere Arten ab:

// Abbrechen einer Coroutine: cancel, kooperativer Abbruch, finally und NonCancellable
package async17

import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.NonCancellable
import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.currentCoroutineContext
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import kotlinx.coroutines.yield

var start = 0L

fun main() = runBlocking {
    // 1 - ein aus delay-Wartezeiten bestehender Download kann ohne besondere Vorkehrungen abgebrochen werden
    start = System.nanoTime()
    val downloading = launch { download(10) }
    delay(1000)
    // cancel() fordert den Abbruch an, join() wartet, bis die Coroutine vollständig gestoppt ist
    downloading.cancel()
    downloading.join()
    display("1 - isCancelled=${downloading.isCancelled}, isCompleted=${downloading.isCompleted}")

    // 2 - eine Berechnung, die nie aussetzt, ignoriert die Abbruchanforderung
    start = System.nanoTime()
    val computation2 = launch(Dispatchers.Default) { compute(checkCancellation = false) }
    delay(300)
    display("2 - cancellation request of the computation")
    computation2.cancelAndJoin()
    display("2 - isCancelled=${computation2.isCancelled}")

    // 3 - eine Berechnung, die regelmäßig prüft, ob sie abgebrochen wurde
    start = System.nanoTime()
    val computation3 = launch(Dispatchers.Default) { compute(checkCancellation = true) }
    delay(300)
    display("3 - cancellation request of the computation")
    computation3.cancelAndJoin()
    display("3 - isCancelled=${computation3.isCancelled}")

    // 4 - auf dem Thread von runBlocking lässt yield() die anderen Coroutinen arbeiten
    start = System.nanoTime()
    val computation4 = launch {
        var rounds = 0L
        while (true) {
            rounds++
            // alle zehn Millionen Durchläufe wird der Thread abgegeben (und der Abbruch geprüft)
            if (rounds % 10_000_000 == 0L) yield()
        }
    }
    delay(300)
    display("4 - the main coroutine was able to take over again: cancellation of the computation")
    computation4.cancelAndJoin()
    display("4 - isCancelled=${computation4.isCancelled}")

    // 5 - das Aufräumen einer abgebrochenen Coroutine: finally und NonCancellable, wenn dabei ausgesetzt werden muss
    start = System.nanoTime()
    val downloading5 = launch {
        try {
            download(10)
        } finally {
            // eine abgebrochene Coroutine kann nicht mehr aussetzen: delay würde sofort eine Exception werfen…
            try {
                delay(100)
            } catch (e: CancellationException) {
                display("  finally: delay throws ${e.javaClass.simpleName}")
            }
            // … außer in einem Block, der mit dem Kontext NonCancellable ausgeführt wird
            withContext(NonCancellable) {
                display("  finally: closing the connection…")
                delay(200)
                display("  finally: connection closed")
            }
        }
    }
    delay(700)
    downloading5.cancelAndJoin()
    display("5 - end of the cancelled download")
}

// simuliert den Download von [nbBlocks] Datenblöcken (ein Block alle 300 ms)
suspend fun download(nbBlocks: Int) {
    try {
        for (i in 1..nbBlocks) {
            // delay wirft eine CancellationException, wenn die Coroutine während des Wartens abgebrochen wird
            delay(300)
            display("  block $i/$nbBlocks received")
        }
    } catch (e: CancellationException) {
        display("  download cancelled (${e.javaClass.simpleName})")
        // eine abgefangene CancellationException muss erneut geworfen werden
        throw e
    }
}

// eine lange Berechnung; bei Bedarf prüft sie alle zehn Millionen Durchläufe, ob ihre Coroutine aktiv ist
suspend fun compute(checkCancellation: Boolean) {
    var sum = 0L
    for (i in 1..1_000_000_000L) {
        if (checkCancellation && i % 10_000_000 == 0L && !currentCoroutineContext().isActive) {
            display("  computation interrupted at round $i")
            return
        }
        sum += i % 7
    }
    display("  computation finished, sum = $sum")
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) = println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async17.Async17Kt
  322 ms :   block 1/10 received
  647 ms :   block 2/10 received
  947 ms :   block 3/10 received
 1022 ms :   download cancelled (JobCancellationException)
 1027 ms : 1 - isCancelled=true, isCompleted=true
  314 ms : 2 - cancellation request of the computation
 1237 ms :   computation finished, sum = 3000000003
 1240 ms : 2 - isCancelled=true
  301 ms : 3 - cancellation request of the computation
  306 ms :   computation interrupted at round 170000000
  307 ms : 3 - isCancelled=true
  323 ms : 4 - the main coroutine was able to take over again: cancellation of the computation
  324 ms : 4 - isCancelled=true
  301 ms :   block 1/10 received
  602 ms :   block 2/10 received
  700 ms :   download cancelled (JobCancellationException)
  705 ms :   finally: delay throws JobCancellationException
  707 ms :   finally: closing the connection…
  908 ms :   finally: connection closed
  909 ms : 5 - end of the cancelled download

Kommentare:

  • Zeilen 84–95: Der simulierte Download erhält alle 300 ms einen Block. Er erfordert keine besonderen Maßnahmen, um abbrechbar zu sein: [delay] ist abbrechbar. Wir fangen [CancellationException] ab, um den Abbruch zu signalisieren, und werfen sie dann erneut: Eine abgefangene [CancellationException] muss immer erneut geworfen werden; andernfalls würde die Coroutine weiterlaufen, als wäre nichts geschehen, obwohl sie abgebrochen wurde (und jede abbrechbare Funktion, die sie anschließend aufruft, würde sofort eine neue Ausnahme auslösen). Aus demselben Grund ist Vorsicht geboten bei einem ***[catch (e: Exception)]**, das auch *[CancellationException]* abfängt, oder bei der Funktion der Standardbibliothek [runCatching]*, die alles abfängt;
  • Zeilen 19–26: Nach einer Sekunde bricht das Programm den Download mit *[cancel()] ab und wartet dann mit *[join()] auf sein Ende. Der Download stoppt sofort, mitten im Warten auf den vierten Block (Zeilen 2–5 der Ergebnisse); eine abgebrochene und beendete Coroutine hat [isCancelled=true] und [isCompleted=true] (Zeile 6). Anders als bei [cancel] oder [CompletableFuture] wird die Operation selbst gestoppt, nicht nur das Warten auf ihr Ergebnis;
  • Zeilen 99–109: eine Milliarde Iterationen einer beliebigen Berechnung. Auf Anforderung prüft die Berechnung alle zehn Millionen Iterationen, ob ihre Coroutine noch aktiv ist: [currentCoroutineContext()] gibt den Kontext der aktuellen Coroutine zurück, und seine Erweiterungseigenschaft [isActive] zeigt an, ob der mit diesem Kontext verbundene [Job] aktiv ist. Wir hätten stattdessen [currentCoroutineContext().ensureActive()] schreiben können, was eine [CancellationException] auslöst, wenn die Coroutine abgebrochen ist;
  • Zeilen 28–34: Die Berechnung wird auf [Dispatchers.Default] ohne Prüfung gestartet. Die Abbruchanforderung bei 300 ms (Zeile 7) hat darauf keine Wirkung: Sie läuft bis zum Ende (Zeile 8), und [cancelAndJoin()] wartet auf dieses Ende. [Job] befindet sich dennoch im Zustand „abgebrochen“ (Zeile 9);
  • Zeilen 36–42: dieselbe Berechnung mit der Prüfung: Sie stoppt einige Millisekunden nach der Abbruchanforderung (Zeilen 10–12);
  • Zeilen 44–57: Eine unendliche Berechnung wird gestartet, diesmal im Thread von [runBlocking], den sie mit der Haupt-Coroutine teilt. Ohne [yield()] würde sie den Thread ganz für sich behalten: Die Haupt-Coroutine könnte nach ihrem [delay(300)] nie fortgesetzt werden und könnte daher die Berechnung auch nicht abbrechen, und das Programm würde nie enden. [yield()] suspendiert die Coroutine und stellt sie wieder in die Warteschlange ihres Dispatchers, wodurch der Thread für andere Coroutinen frei bleibt; ist die Coroutine inzwischen abgebrochen worden, löst [yield()] eine [CancellationException] aus, die die Schleife beendet (Zeilen 13 und 14);
  • Zeilen 59–81: Aufräumen einer abgebrochenen Coroutine in einem [finally]-Block. Das Schließen einer Verbindung kann den Aufruf einer Suspend-Funktion erfordern; eine abgebrochene Coroutine kann sich jedoch nicht mehr selbst suspendieren: Jede abbrechbare Funktion löst sofort eine [CancellationException] aus, wie das [delay(100)] im [finally]-Block zeigt (Zeile 18). Damit dennoch Code ausgeführt werden kann, der suspendiert, wird er mit [withContext(NonCancellable) { … }] ausgeführt: [NonCancellable] ist ein [Job] , der nie abgebrochen wird, und der Block läuft normal bis zu seinem Ende (Zeilen 19 und 20). Der Block muss kurz sein: Er verzögert den Abschluss des Abbruchs, auf den [cancelAndJoin()] wartet (Zeile 21).

Beachten Sie, dass der Abbruch keine abrupte Unterbrechung ist: Er ist eine Ausnahme, die an den Suspendierungspunkten geworfen wird und sich durch den Code zurückarbeitet, wobei sie die [finally]-Blöcke ausführt. Jeder mit abbrechbaren Suspend-Funktionen geschriebene Code lässt sich mühelos abbrechen; eine lange Berechnung muss regelmäßig [isActive] prüfen oder [ensureActive()] oder [yield()] aufrufen.

9.7.2. Mehrere Prozesse, mehrere Ergebnisse

Das Programm [Async18.kt] übernimmt das Java-Programm, das fünf Prozesse mit einer Dauer von 1 bis 5 Sekunden startete, von denen Prozess Nr. 3 eine Ausnahme wirft und Prozess Nr. 4 abgebrochen wird. Es verarbeitet jeden Prozess, sobald er beendet ist, unabhängig davon, wie er geendet hat, und weiß immer, um welchen Prozess es sich handelt:

// fünf Verarbeitungen von 1 bis 5 Sekunden: Nr. 3 wirft eine Exception, Nr. 4 wird abgebrochen
package async18

import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.selects.select
import kotlinx.coroutines.supervisorScope

// das Ergebnis einer Verarbeitung
data class ProcessingResult(val duration: Int, val actualDuration: Double)

var start = 0L

fun main() = runBlocking {
    start = System.nanoTime()
    // supervisorScope: der Fehlschlag einer Verarbeitung bricht die anderen nicht ab
    supervisorScope {
        val processings = List(5) { number -> async { sleep(number, number + 1) } }
        // Verarbeitung Nr. 4 wird nach 2,5 Sekunden abgebrochen
        launch {
            delay(2500)
            processings[4].cancel()
        }
        display("the ${processings.size} processings are launched")

        // jede Verarbeitung wird verwendet, sobald sie beendet ist, egal auf welche Weise sie endet
        val inProgress = processings.withIndex().toMutableList()
        while (inProgress.isNotEmpty()) {
            // select gibt die erste beendete Verarbeitung mit ihrer Nummer zurück
            val finished = select {
                inProgress.forEach { processing -> processing.value.onJoin { processing } }
            }
            inProgress.remove(finished)
            val (number, processing) = finished
            // die Verarbeitung ist beendet: await() gibt sofort ihr Ergebnis zurück oder wirft ihre Exception
            val report = try {
                val result = processing.await()
                "finished: scheduled duration %d s, actual duration %.1f s"
                    .format(result.duration, result.actualDuration)
            } catch (_: CancellationException) {
                "cancelled"
            } catch (e: IllegalStateException) {
                "encountered the following error: ${e.message}"
            }
            display("processing $number $report")
        }
    }
}

// die Verarbeitung: [duration] Sekunden schlafen, in Scheiben von einer Sekunde
suspend fun sleep(number: Int, duration: Int): ProcessingResult {
    val processingStart = System.nanoTime()
    // Exception für Verarbeitung Nr. 3
    check(number != 3) { "test...." }
    repeat(duration) { delay(1000) }
    // das an den Aufrufer zurückgegebene Ergebnis
    return ProcessingResult(duration, (System.nanoTime() - processingStart) / 1e9)
}

// Anzeige mit der seit Beginn verstrichenen Zeit in Sekunden
fun display(message: String) = println("%4.1f s : %s".format((System.nanoTime() - start) / 1e9, message))

Ergebnisse:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=async18.Async18Kt
 0.0 s : the 5 processings are launched
 0.1 s : processing 3 encountered the following error: test....
 1.1 s : processing 0 finished: scheduled duration 1 s, actual duration 1.0 s
 2.1 s : processing 1 finished: scheduled duration 2 s, actual duration 2.0 s
 2.6 s : processing 4 cancelled
 3.1 s : processing 2 finished: scheduled duration 3 s, actual duration 3.0 s

Kommentare:

  • Zeilen 53–60: die Verarbeitung. Prozess Nr. 3 schlägt sofort fehl: Die Funktion [check] (Kapitel 3) wirft eine [IllegalStateException] , wenn ihre Bedingung falsch ist. Die anderen „schlafen“ [duration] Sekunden lang in Schritten von einer Sekunde mit [delay] (das abgebrochen werden kann) und geben ein Ergebnis zurück – eine Datenklasse ([ProcessingResult], Zeile 13) –, das die geplante und die tatsächliche Dauer enthält;
  • Zeile 20: Die Prozesse sind unabhängig: In einem Supervisor-Scope bricht der Fehlschlag von Prozess Nr. 3 die anderen nicht ab;
  • Zeile 21: Die fünf Prozesse werden mit [async] gestartet; die Liste der fünf [Deferred<ProcessingResult>] wird durch [List(5) { number -> … }] erstellt;
  • Zeilen 22–25: Eine Coroutine bricht Prozess Nr. 4 nach 2,5 Sekunden ab, obwohl dieser noch 2,5 Sekunden Schlaf vor sich hat. Das Java-Programm benötigte dafür einen *[ScheduledExecutorService]*; hier genügt eine Coroutine, die mit einem *[delay]* beginnt;
  • Zeile 30: [withIndex()] ordnet jeder Aufgabe ihre Nummer zu, in Form von [IndexedValue]-Objekten (einer Datenklasse mit zwei Eigenschaften, [index] und [value]), die in einer veränderlichen Liste der laufenden Prozesse gespeichert werden;
  • Zeilen 33–36: Solange es laufende Prozesse gibt, wartet [select] auf den ersten, der endet, unabhängig davon, wie er endet: Die [onJoin]-Klausel eines [Job] wird ausgewählt, sobald er abgeschlossen ist – ob erfolgreich, erfolglos oder abgebrochen. Die Klausel gibt den [IndexedValue] des Prozesses zurück, der dann aus der Liste entfernt wird;
  • Zeile 37: Die destrukturierende Zuweisung trennt die Nummer vom Prozess;
  • Zeilen 39–46: Das Ergebnis der Verarbeitung wird mit [await()] untersucht, das die Ausführung nicht mehr blockiert: Es gibt das Ergebnis zurück, wirft die Ausnahme der Verarbeitung oder wirft eine [CancellationException], wenn sie abgebrochen wurde. Die Reihenfolge der [catch]-Aufrufe ist wichtig: [CancellationException] ist von [IllegalStateException] abgeleitet (sie ist eine Unterklasse im JDK), daher muss sie zuerst abgefangen werden. Das Abfangen einer *[CancellationException]* ohne erneutes Werfen ist hier zulässig, da sie von einem anderen *[Job]* stammt – dem abgebrochenen Prozess – und nicht von der Coroutine, die sie abfängt;
  • Die Ergebnisse zeigen, dass Nr. 3 sofort fehlschlägt, dass die Nrn. 0, 1 und 2 nach 1, 2 bzw. 3 Sekunden enden und dass Nr. 4 nach 2,5 Sekunden abgebrochen wird. Das Java-Programm prüfte den Zustand der [Future] mit [switch] , um die Konstanten von [Future.State] zu untersuchen; mit Coroutinen wird das Ergebnis eines Prozesses ganz natürlich mit [try / catch] gelesen.

9.7.3. Die Dauer eines Wartens begrenzen: withTimeout und withTimeoutOrNull

Kotlinx.coroutines stellt zwei Suspend-Funktionen bereit, die die Dauer eines Codeblocks begrenzen:

  • [withTimeout(timeout) { … }] führt den Block aus und gibt seinen Wert zurück; wird der Block nicht innerhalb des Zeitlimits abgeschlossen, wird er abgebrochen, und [withTimeout] löst eine [TimeoutCancellationException] aus (eine von [CancellationException] abgeleitete Klasse);
  • [withTimeoutOrNull(timeout) { … }] tut dasselbe, gibt aber [null] zurück, statt eine Ausnahme zu werfen.

Das Timeout wird in Millisekunden oder als Dauer angegeben ([withTimeout(2.seconds)]). Das Programm [Async19.kt] demonstriert diese beiden Funktionen, ihre Grenzen (den blockierenden Code) und wie man zwei Abbruchbedingungen kombiniert:

// Begrenzung der Dauer eines Wartens: withTimeout, withTimeoutOrNull, runInterruptible
package async19

import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.TimeoutCancellationException
import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.runInterruptible
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeout
import kotlinx.coroutines.withTimeoutOrNull

var start = 0L

fun main() = runBlocking {
    // 1 - withTimeout: wir warten nicht länger als eine Sekunde, und die Operation wird abgebrochen
    start = System.nanoTime()
    try {
        display("1 - answer: ${withTimeout(1000) { query("slow-server", 3000) }}")
    } catch (e: TimeoutCancellationException) {
        display("1 - ${e.javaClass.simpleName} : ${e.message}")
    }

    // 2 - withTimeoutOrNull: nach einer Sekunde begnügen wir uns mit einer Standardantwort
    start = System.nanoTime()
    val answer = withTimeoutOrNull(1000) { query("slow-server", 3000) } ?: "default answer"
    display("2 - $answer")

    // 3 - blockierender Code ignoriert den Abbruch: withTimeout wartet, bis er beendet ist
    start = System.nanoTime()
    try {
        withTimeout(1000) {
            withContext(Dispatchers.IO) { queryBlocking("slow-server", 3000) }
        }
    } catch (e: TimeoutCancellationException) {
        display("3 - ${e.javaClass.simpleName}, but after three seconds")
    }

    // 4 - runInterruptible: der Abbruch der Coroutine unterbricht den Thread, der den blockierenden Code ausführt
    start = System.nanoTime()
    try {
        withTimeout(1000) {
            runInterruptible(Dispatchers.IO) { queryBlocking("slow-server", 3000) }
        }
    } catch (e: TimeoutCancellationException) {
        display("4 - ${e.javaClass.simpleName} after one second")
    }

    // 5 - zwei Stoppursachen: das für jede Verarbeitung spezifische Timeout und ein allgemeiner Stopp
    start = System.nanoTime()
    val all = launch {
        launch { processWithTimeout("fast", 500, 1000) }
        launch { processWithTimeout("slow", 3000, 1000) }
        launch { processWithTimeout("medium", 1500, 2000) }
    }
    // der Aufrufer fordert den allgemeinen Stopp nach 1200 ms an
    delay(1200)
    display("5 - general stop requested")
    all.cancelAndJoin()
}

// eine auf [timeout] Millisekunden begrenzte Verarbeitung, die auch vom Aufrufer abgebrochen werden kann
suspend fun processWithTimeout(name: String, duration: Long, timeout: Long) {
    val message = try {
        withTimeout(timeout) { query(name, duration) }
    } catch (_: TimeoutCancellationException) {
        "$name: timeout of $timeout ms exceeded"
    } catch (e: CancellationException) {
        display("5 - $name: stopped at the caller's request")
        throw e
    }
    display("5 - $message")
}

// simuliert einen Server, der nach [duration] Millisekunden antwortet
suspend fun query(server: String, duration: Long): String {
    try {
        delay(duration)
        return "$server answered in $duration ms"
    } catch (e: CancellationException) {
        display("  $server: operation cancelled")
        throw e
    }
}

// dieselbe Operation, blockierend geschrieben
fun queryBlocking(server: String, duration: Long): String {
    try {
        Thread.sleep(duration)
        display("  $server has finished its work")
        return "$server answered in $duration ms"
    } catch (e: InterruptedException) {
        display("  $server was interrupted")
        throw e
    }
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) = println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async19.Async19Kt
 1009 ms :   slow-server: operation cancelled
 1028 ms : 1 - TimeoutCancellationException : Timed out waiting for 1000 ms
 1001 ms :   slow-server: operation cancelled
 1002 ms : 2 - default answer
 3014 ms :   slow-server has finished its work
 3022 ms : 3 - TimeoutCancellationException, but after three seconds
 1001 ms :   slow-server was interrupted
 1003 ms : 4 - TimeoutCancellationException after one second
  504 ms : 5 - fast answered in 500 ms
 1004 ms :   slow: operation cancelled
 1005 ms : 5 - slow: timeout of 1000 ms exceeded
 1201 ms : 5 - general stop requested
 1204 ms :   medium: operation cancelled
 1204 ms : 5 - medium: stopped at the caller's request

Kommentare:

  • Zeilen 78–85: der simulierte Server, der seinen Abbruch signalisiert;
  • Zeilen 19–24: Wir warten nicht länger als eine Sekunde auf eine Antwort. Nach einer Sekunde wird der Block abgebrochen: Die Operation stoppt tatsächlich (Zeile 2 der Ergebnisse), dann wirft [withTimeout] eine [TimeoutCancellationException] mit einer Meldung, die sich auf das Timeout bezieht (Zeile 3). Dies ist ein bedeutender Unterschied zur Methode [orTimeout] von [CompletableFuture], die das Warten aufgab, die Operation aber unnötigerweise weiterlaufen ließ;
  • Zeilen 27–30: [withTimeoutOrNull] gibt [null] zurück, wenn das Timeout überschritten wird; der Elvis-Operator [?:] ersetzt dann [null] durch eine Standardantwort (Zeilen 4 und 5). Dies ist das Äquivalent zu [completeOnTimeout], aber kürzer, und auch hier wird die Operation tatsächlich beendet;
  • Zeilen 32–39: die Grenze des kooperativen Abbruchs. Der auf eine Sekunde begrenzte Block führt eine blockierende Funktion ([queryBlocking], Zeilen 89–97) auf [Dispatchers.IO] aus, die drei Sekunden lang mit [Thread.sleep] schläft. Nach einer Sekunde wird die Coroutine zwar abgebrochen, aber nichts kann [Thread.sleep] stoppen: Die Funktion läuft bis zum Ende (Zeile 6), und erst bei der Rückkehr von [withContext], drei Sekunden später, wird [TimeoutCancellationException] ausgelöst (Zeile 7). Die Verzögerung hat keinen Zweck erfüllt;
  • Zeilen 42–49: Damit der Abbruch einer Coroutine blockierenden Code stoppt, wird dieser mit [runInterruptible(dispatcher) { … }] ausgeführt: Die Funktion führt den Block auf dem angegebenen Dispatcher aus und unterbricht, wenn die Coroutine abgebrochen wird, den Thread, der ihn ausführt, mit der Java-Methode [interrupt()]. [Thread.sleep] löst dann [InterruptedException] aus (Zeile 8), die [runInterruptible] in [CancellationException] umwandelt. Dies schafft eine Brücke zwischen dem Abbruch von Coroutinen und der Thread-Unterbrechung: Die Operation stoppt nach einer Sekunde (Zeile 9). Das funktioniert nur für unterbrechbaren blockierenden Code ([Thread.sleep], die Wartevorgänge in [java.util.concurrent], die Channels in [java.nio]…);
  • Zeilen 65–75: ein Prozess, der aus zwei Gründen gestoppt werden kann – wegen seines eigenen Timeouts oder wegen einer allgemeinen Stoppanforderung des Aufrufers. Beides tritt in Form einer Ausnahme auf: eine [TimeoutCancellationException] , die von [withTimeout] bei Ablauf des Timeouts ausgelöst wird, und eine [CancellationException] für den Abbruch der Coroutine durch den Aufrufer. Das Timeout ist ein normales Ergebnis der Verarbeitung, das in eine Meldung umgewandelt wird; der Abbruch dagegen wird signalisiert und dann erneut geworfen. Die beiden [catch]-Blöcke müssen in dieser Reihenfolge stehen, da [TimeoutCancellationException] von [CancellationException] abgeleitet ist;
  • Zeilen 52–62: drei Prozesse, Kinder derselben Coroutine [all]. Für das allgemeine Beenden musste das Java-Programm ein zusätzliches [CompletableFuture] erstellen und eine Continuation anhängen, die jedes Warten abbrach; hier ist das allgemeine Beenden einfach der Abbruch des Elternteils, der seinerseits seine Kinder abbricht. Der Prozess [fast] endet normal (Zeile 10), der Prozess [slow] überschreitet sein Timeout von einer Sekunde (Zeilen 11 und 12), und der Prozess [medium], dem 2 Sekunden zugestanden wurden, wird bei 1.200 ms durch das allgemeine Beenden beendet (Zeilen 13–15).

9.8. Fortschritt melden

Eine lang laufende Operation muss oft ihren Fortschritt melden (ein Fortschrittsbalken, eine Prozentangabe). Am einfachsten übergibt man ihr eine Callback-Funktion , die Fortschrittsmeldungen erhält. In Java war dies ein [Consumer<T>]; in Kotlin ist es schlicht ein Funktionsparameter (Kapitel 7), [(Progress) -> Unit]. Die Operation ruft diese Funktion bei jedem Schritt auf; sie weiß nichts darüber, wie die Fortschrittsmeldungen angezeigt werden.

In einer grafischen Anwendung stellt sich die Frage der Threads: Grafische Komponenten dürfen nur vom UI-Thread aktualisiert werden. Mit Coroutinen ist die Antwort einfach: Wurde die Coroutine, die die Operation ausführt, auf *[Dispatchers.Main] gestartet, werden die Meldungen im UI-Thread ausgegeben, und die Callback-Funktion kann die Komponenten direkt aktualisieren; führt die Operation einen Teil ihrer Arbeit anderswo aus (mit [withContext(Dispatchers.IO)]), meldet sie ihre Ergebnisse außerhalb dieses Blocks, oder die Callback-Funktion kehrt mit [withContext(Dispatchers.Main)] in den Oberflächen-Thread zurück (sie ist dann selbst eine Suspend-Funktion vom Typ [suspend (Progress) -> Unit]). In einem Konsolenprogramm kann sie direkt ausgeben. Das Programm [Async20.kt] simuliert einen Kopiervorgang, den der Benutzer durch Eingabe von [Enter]* abbrechen kann:

// Melden des Fortschritts einer Operation mit einer Callback-Funktion; der Benutzer kann sie abbrechen
package async20

import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlin.concurrent.thread

// eine Fortschrittsmeldung
data class Progress(val percentage: Int, val file: String)

fun main() = runBlocking {
    println("Copy in progress, press [Enter] to cancel it")
    // das Kopieren wird von einer Coroutine ausgeführt; die Funktion display zeigt ihre Meldungen an
    val copy = async { copyFiles(8, ::display) }
    // ein Daemon-Thread wartet darauf, dass der Benutzer [Enter] drückt, um das Kopieren abzubrechen
    thread(isDaemon = true) {
        // readlnOrNull gibt null zurück, wenn die Standardeingabe geschlossen ist: nichts wird abgebrochen
        if (readlnOrNull() != null) {
            copy.cancel()
        }
    }
    try {
        println("Copy finished: ${copy.await()} files copied")
    } catch (_: CancellationException) {
        println("Copy cancelled by the user")
    }
}

// die Operation weiß nicht, wie ihr Fortschritt angezeigt wird: sie meldet ihn nur
suspend fun copyFiles(nbFiles: Int, progress: ((Progress) -> Unit)? = null): Int {
    for (i in 1..nbFiles) {
        // das Kopieren einer Datei
        delay(300)
        // die Fortschrittsmeldung, falls der Aufrufer eine wünscht
        progress?.invoke(Progress(100 * i / nbFiles, "file$i.dat"))
    }
    return nbFiles
}

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

Ergebnisse ohne Abbruch (die Standardeingabe ist geschlossen: [readlnOrNull()] gibt sofort [null] zurück):

> gradlew -q run -Pmain=async20.Async20Kt
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 [Enter] während des Kopiervorgangs nach etwa eineinhalb Sekunden eingibt (die eingegebene leere Zeile erscheint nicht: Die Eingabe wurde dem Programm durch Umleitung seiner Standardeingabe zugeführt):

1
2
3
4
5
6
7
> gradlew -q run -Pmain=async20.Async20Kt
Copy in progress, press [Enter] to cancel it
[##..................]  12 % file1.dat
[#####...............]  25 % file2.dat
[#######.............]  37 % file3.dat
[##########..........]  50 % file4.dat
Copy cancelled by the user

Kommentare:

  • Zeile 11: eine Fortschrittsmeldung, eine Datenklasse, die den Prozentsatz und den Dateinamen enthält;
  • Zeilen 31–39: die Operation, eine Suspend-Funktion. Ihr Parameter [progress] hat den Typ [((Progress) -> Unit)?]: eine Funktion, die ein [Progress] akzeptiert und nichts zurückgibt, oder [null] , wenn der Aufrufer keine Meldungen wünscht, was der Standardwert ist. Nach jeder Datei meldet sie ihren Fortschritt über [progress?.invoke(...)]: Der Aufruf von [?.] tut nichts, wenn [progress] gleich [null] ist (man kann nicht [progress?(...)] aufrufen: Man muss die Methode [invoke] des funktionalen Typs verwenden). Die Wartezeit von 300 ms mit [delay] macht die Operation abbrechbar;
  • Zeilen 42–46: Anzeige eines Berichts: ein Balken aus 20 Zeichen, der mit [repeat] erzeugt wird. Die Funktionsreferenz [::display] (Zeile 16) ist die Callback-Funktion, die an die Operation übergeben wird;
  • Zeile 16: Das Kopieren wird von einer Coroutine auf dem [runBlocking]-Thread ausgeführt;
  • Zeilen 17–21: Ein Thread wartet darauf, dass der Benutzer [Enter] eingibt, und bricht dann das Kopieren ab. [readlnOrNull()] ist ein blockierendes Lesen von der Standardeingabe, das sich nicht abbrechen lässt. Es kann daher nicht in einer Coroutine im Gültigkeitsbereich von [runBlocking] ausgeführt werden: Die strukturierte Nebenläufigkeit würde [runBlocking] zwingen, auf das Ende dieser Coroutine zu warten – also darauf, dass der Benutzer etwas eingibt –, selbst nachdem das Kopieren abgeschlossen ist. Es wird in einem Thread ausgeführt, der von der Funktion [thread] mit [isDaemon = true] erzeugt wird: ein Daemon-Thread, den das Programm beim Beenden verwirft. Dies ist ein Fall, in dem Sie die strukturierte Nebenläufigkeit bewusst verlassen müssen; das geschieht mit einem expliziten Werkzeug (einem Daemon-Thread), nicht mit [GlobalScope]. Die Methode [cancel()] eines [Job] kann von jedem Thread aus aufgerufen werden;
  • Zeilen 24–27: Das Programm wartet auf das Ende des Kopierens. Der Abbruch führt zu einer [CancellationException], die von [await()] ausgelöst wird. Wie in [Async18.kt] lässt sie sich abfangen, ohne sie erneut auszulösen, da sie aus dem Abbruch einer anderen Coroutine – der Kopieroperation – resultiert; ein Fehler der Kopieroperation würde sich dagegen bis zu [runBlocking] fortpflanzen und das Programm beenden.

Eine Callback-Funktion eignet sich für einfache Berichte. Im weiteren Verlauf dieses Kapitels wird ein allgemeineres Werkzeug zur asynchronen Erzeugung einer Wertefolge vorgestellt: der Stream ([Flow]): Eine Operation, die einen [Flow<Progress>] zurückgibt, meldet ihre Ergebnisse, sobald sie verfügbar sind, und der Aufrufer sammelt sie mit [collect] auf dem Dispatcher seiner Wahl.

9.9. Asynchrone Ein-/Ausgabe

9.9.1. Dateien

Ein-/Ausgabe ist der eigentliche Grund für Asynchronität. Für Dateien bietet das JDK zwei Klassenfamilien an, die Kotlin direkt verwendet:

  • die „klassischen“, blockierenden Klassen: [Files], [BufferedReader], [BufferedWriter] und die Erweiterungsfunktionen, die Kotlin ihnen hinzufügt (Kapitel 5): [readLines], [readText], [useLines], [bufferedWriter], [writeText], [appendText] … In einem Coroutine-Programm werden sie auf dem Dispatcher [Dispatchers.IO] ausgeführt, der für blockierende Operationen vorgesehen ist, zusammen mit [withContext(Dispatchers.IO) { … }]: Die aufrufende Coroutine wird suspendiert – ohne ihren Thread zu blockieren –, während ein Thread des [IO]-Dispatchers die Operation ausführt;
  • die Klasse [AsynchronousFileChannel] (Java 7), deren Operationen ein [Future] zurückgeben oder einen [CompletionHandler] aufrufen. Sie wird nur 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. Sie wird mit [suspendCancellableCoroutine] für Coroutinen adaptiert, wie beim TCP-Client im Programm [Async02.kt].

Das Programm [Async21.kt] zeigt beide Familien, indem es aus dem Hauptthread die Datei mit den Steuerstufen liest, [TaxData.txt], die sich im Stammverzeichnis des Projekts befindet:

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 Stufenschwelle, 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 des Jahres 2003, der für dieses Steuerjahr unverändert übernommen wurde). Das Programm läuft im Ordner [09-async] (dies ist das aktuelle Verzeichnis für [gradlew run]) und sucht seine Dateien im aktuellen Ordner. Die Datei [taxpayers.txt], die in der Übung am Ende des Kapitels verwendet wird, liegt am selben Ort.

// Datei-Ein-/Ausgabe: AsynchronousFileChannel, angepasst als suspendierende Funktion,
// dann gewöhnliche blockierende E/A, an den IO-Dispatcher übergeben
package async21

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.withContext
import java.math.BigDecimal
import java.nio.ByteBuffer
import java.nio.channels.AsynchronousFileChannel
import java.nio.channels.CompletionHandler
import java.nio.file.Path
import java.nio.file.StandardOpenOption
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.io.path.appendText
import kotlin.io.path.bufferedWriter
import kotlin.io.path.deleteExisting
import kotlin.io.path.readLines
import kotlin.io.path.readText
import kotlin.io.path.useLines
import kotlin.time.measureTimedValue

val data: Path = Path.of("TaxData.txt")
val report: Path = Path.of("report-21.txt")

fun main() = runBlocking {
    // 1 - AsynchronousFileChannel (Java 7): ein Lesen mit Callback, in eine suspendierende Funktion umgewandelt
    val content = readAsynchronously(data)
    println("1 - AsynchronousFileChannel: ${content.trimEnd().lines().size} lines")

    // 2 bis 7 - gewöhnliche blockierende E/A, auf dem IO-Dispatcher ausgeführt
    processFiles()

    // 8 - mehrere Dateien parallel gelesen: eine Coroutine pro Datei, auf dem IO-Dispatcher
    val files = listOf("TaxData.txt", "taxpayers.txt", "TaxData.txt").map { Path.of(it) }
    val (nbLines, duration) = measureTimedValue {
        files.map { file -> async { readSlowly(file) } }.awaitAll()
    }
    println("8 - lines read in parallel: $nbLines in ${duration.inWholeMilliseconds} ms")
}

// liest eine ganze (kleine) Datei mit einem AsynchronousFileChannel, ohne einen Thread zu blockieren
suspend fun readAsynchronously(file: Path): String =
    AsynchronousFileChannel.open(file, StandardOpenOption.READ).use { channel ->
        val buffer = ByteBuffer.allocate(channel.size().toInt())
        // die Coroutine wird ausgesetzt; die Callback-Methode setzt sie fort
        val nbBytes = suspendCancellableCoroutine { continuation ->
            channel.read(buffer, 0, Unit, object : CompletionHandler<Int, Unit> {
                override fun completed(nbBytes: Int, attachment: Unit) = continuation.resume(nbBytes)
                override fun failed(e: Throwable, attachment: Unit) = continuation.resumeWithException(e)
            })
        }
        String(buffer.array(), 0, nbBytes, Charsets.UTF_8)
    }

// blockierende E/A: withContext lässt sie von einem Thread des IO-Dispatchers ausführen
suspend fun processFiles() = withContext(Dispatchers.IO) {
    // 2 - Lesen der ganzen Datei in einer einzigen Operation
    val lines = data.readLines()
    println("2 - readLines: ${lines.size} lines [${Thread.currentThread().name}]")

    // 3 - zeilenweises Lesen: useLines liefert eine Sequenz von Zeilen und schließt die Datei
    val brackets = data.useLines { sequence -> sequence.map(TaxBracket::parse).toList() }
    println("3 - useLines: ${brackets.size} brackets, 2nd: ${brackets[1]}")

    // 4 - die Sequenz der Zeilen wird bei Bedarf gelesen: die Datei wird nicht in den Speicher geladen
    println("4 - useLines + count: ${data.useLines { it.count() }} lines")

    // 5 - Schreiben mit einem BufferedWriter, durch use geschlossen
    report.bufferedWriter().use { writer ->
        writer.write("Brackets of the tax scale (exercise: 2004 tax scale on 2003 income)")
        writer.newLine()
        brackets.forEachIndexed { i, bracket ->
            val limit = if (bracket.limit.signum() == 0) "above"
            else "up to %,d €".format(bracket.limit.toInt())
            writer.write("bracket %d : %-18s rate %.1f %%".format(i + 1, limit,
                bracket.coeffR * BigDecimal(100)))
            writer.newLine()
        }
    }

    // 6 - Lesen der ganzen Datei als String
    print("5 and 6 - content of [$report]:\n${report.readText()}")

    // 7 - Anhängen ans Ende der Datei, dann Löschen
    report.appendText("end of the report\n")
    println("7 - last line: ${report.readLines().last()}")
    report.deleteExisting()
}

// ein blockierendes Lesen, das 500 ms dauert (zum Beispiel eine Datei auf einem langsamen Datenträger)
suspend fun readSlowly(file: Path): Int = withContext(Dispatchers.IO) {
    Thread.sleep(500)
    file.readLines().size
}

// eine Steuerstufe; die Datei verwendet den Dezimalpunkt, den BigDecimal versteht
data class TaxBracket(val limit: BigDecimal, val coeffR: BigDecimal, val coeffN: BigDecimal) {
    companion object {
        fun parse(line: String): TaxBracket {
            val (limit, coeffR, coeffN) = line.split(":").map(::BigDecimal)
            return TaxBracket(limit, coeffR, coeffN)
        }
    }
}

Ergebnisse:

> gradlew -q run -Pmain=async21.Async21Kt
1 - AsynchronousFileChannel: 7 lines
2 - readLines: 7 lines [DefaultDispatcher-worker-1]
3 - useLines: 7 brackets, 2nd: TaxBracket(limit=8382, coeffR=0.068, coeffN=291.09)
4 - useLines + count: 7 lines
5 and 6 - content of [report-21.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 : above              rate 48.1 %
7 - last line: end of the report
8 - lines read in parallel: [7, 7, 7] in 519 ms

Erläuterungen:

  • Zeilen 47–57: Lesen mit einem [AsynchronousFileChannel], dargestellt als Suspend-Funktion, die den Dateiinhalt zurückgibt. Der Kanal ist ein [Closeable]: Die Funktion [use] (Kapitel 3) schließt ihn am Ende des Blocks, unabhängig vom Ergebnis, auch wenn die Coroutine abgebrochen wird. Dies ist dieselbe Technik wie im Programm [Async02.kt]: [suspendCancellableCoroutine] suspendiert die Coroutine und gibt die Kontrolle an den Block zurück; der Lesevorgang wird mit einem Callback-Objekt gestartet, das die Coroutine mit der Anzahl der gelesenen Bytes ([resume]) oder mit der Ausnahme ([resumeWithException]) fortsetzt. Das Java-Programm musste selbst ein [CompletableFuture] erzeugen und beenden und es dann in einer [whenComplete]-Fortsetzung schließen; hier wird der Code von oben nach unten gelesen. Für eine kleine Datei genügt ein einzelner Lesevorgang; eine große Datei würde aufeinanderfolgende Lesevorgänge erfordern, die einfach in einer Coroutine-Schleife geschrieben würden;
  • Zeile 33: Die Kotlin-Funktion [lines()] teilt eine Zeichenkette in Zeilen auf; endet die Zeichenkette mit einem Zeilenumbruch, endet die Liste mit einer leeren Zeichenkette (anders als bei der Java-Methode [lines()]). [trimEnd()] entfernt diesen letzten Zeilenumbruch;
  • Zeile 61: Die übrigen Operationen sind gewöhnliche blockierende Ein-/Ausgabeoperationen, die in der Suspend-Funktion [processFiles] zusammengefasst sind, deren gesamter Rumpf von [withContext(Dispatchers.IO)] ausgeführt wird. Der Thread-Name, der in Zeile 3 der Ergebnisse angezeigt wird ([DefaultDispatcher-worker-…]), zeigt, dass nicht mehr der Hauptthread läuft. Das Java-Programm delegierte diese Operationen an einen virtuellen Thread und musste die [IOException] innerhalb des Lambdas eines [Runnable] abfangen; in Kotlin gibt es keine geprüften Ausnahmen, und eine [IOException] , die im Block von [withContext] ausgelöst wird, würde in der aufrufenden Coroutine erneut ausgelöst;
  • Zeile 63: [readLines()], eine Erweiterungsfunktion von [Path] (Paket [kotlin.io.path]), liest die gesamte Datei und gibt eine Liste ihrer Zeilen zurück (standardmäßig in UTF-8);
  • Zeile 67: [useLines] öffnet die Datei, übergibt dem Block eine Sequenz ([Sequence<String>]) ihrer Zeilen – bei Bedarf gelesen – und schließt die Datei am Ende des Blocks: Das entspricht der [readLine()]-Schleife im Java-Programm, ohne die Behandlung von [null] oder [try] mit Ressource. Jede Zeile wird von der Funktion [parse] des Companion-Objekts der Datenklasse (Zeilen 102–106) in ein [TaxBracket] umgewandelt. Sie zerlegt die Zeile mit [split], wandelt die drei Felder mithilfe der Konstruktorreferenz [::BigDecimal] in [BigDecimal] um und ruft sie über eine Destrukturierungszuweisung ab. Der Konstruktor von [BigDecimal] erwartet einen Dezimalpunkt, unabhängig von der Sprache des Rechners. Die Darstellung, die die Methode [toString] der Datenklasse erzeugt, erscheint in Zeile 4 der Ergebnisse;
  • Zeile 71: Die Zeilensequenz lädt nicht die gesamte Datei in den Speicher; dies ist der bevorzugte Ansatz für große Dateien. Sie kann nur innerhalb des Blocks [useLines] verwendet werden, da die Datei beim Verlassen des Blocks geschlossen wird;
  • Zeilen 73–82: Schreiben mit einem [BufferedWriter], den man über die Erweiterungsfunktion [bufferedWriter()] erhält und der von [use] geschlossen (und damit auf die Festplatte geschrieben) wird. Das Format [%,d] fügt das Tausendertrennzeichen ein, das der Sprache des Rechners entspricht (ein Komma im Englischen, ein schmales geschütztes Leerzeichen im Französischen); das Produkt [bracket.coeffR * BigDecimal(100)] verwendet den Operator [*], den die Kotlin-Standardbibliothek für [BigDecimal] definiert (Erweiterungsfunktion [times], Kapitel 4);
  • Zeilen 86–92: [readText()] liest die geschriebene Datei erneut, [appendText] fügt ihr eine Zeile hinzu, [last()] gibt das letzte Element der Liste zurück, und anschließend löscht [deleteExisting()] die Datei;
  • Zeilen 38–43: Mehrere Dateien werden parallel gelesen. Jeder Lesevorgang wird von einer Coroutine ([async]) übernommen, und [awaitAll()] wartet auf die drei Ergebnisse. Die Funktion [readSlowly] (Zeilen 96–98) simuliert einen blockierenden Lesevorgang von 500 ms auf einer langsamen Festplatte; da sie auf dem Dispatcher [IO] läuft, belegen die drei Lesevorgänge drei verschiedene Threads und dauern zusammen 500 ms, nicht 1,5 s (Zeile 16 der Ergebnisse). Beachten Sie, dass die Coroutinen von [async] ohne Dispatcher gestartet werden: Die aufgerufene Funktion wählt selbst per [withContext] den Dispatcher, der zu ihrer Aufgabe passt. Dies ist die Regel, die es zu befolgen gilt: Eine blockierende Suspend-Funktion muss selbst über den IO-Dispatcher laufen, damit der Aufrufer sie von jedem Thread aus aufrufen kann, ohne besondere Vorkehrungen zu treffen.

Der Dispatcher [IO] begrenzt die Zahl der gleichzeitig aktiven Threads standardmäßig auf 64 (Programm [Async12.kt]). Um Tausende von Dateien gleichzeitig zu lesen, können Sie einen Dispatcher auf Basis virtueller Threads erstellen (Programm [Async09.kt]); beachten Sie die im Java-Kurs erwähnte Einschränkung: Lese- und Schreibvorgänge auf Dateien binden den virtuellen Thread während der Operation an seinen Trägerthread. Bei lokalen Dateien ist das selten ein Problem; bei Netzwerkoperationen geben virtuelle Threads und Coroutinen ihren Thread während der Wartezeiten tatsächlich frei.

9.9.2. Netzwerk: HttpClient

Der HTTP-Client des JDK, [java.net.http.HttpClient] (Java 11), bietet zwei Vorgehensweisen: [send], das blockiert und die Antwort zurückgibt, und [sendAsync], das sofort ein [CompletableFuture] mit der Antwort zurückgibt. In einer Coroutine warten wir auf dieses [CompletableFuture] mit der Suspend-Funktion [await()] aus dem Paket [kotlinx.coroutines.future], der wir bereits im Programm [Async04.kt] begegnet sind: Die Coroutine wird bis zum Eintreffen der Antwort suspendiert, ohne einen Thread zu blockieren. Kapitel 12 behandelt diesen Client im Detail; das Programm [Async22.kt] vergleicht lediglich die beiden Methoden, indem es einen kleinen lokalen HTTP-Server abfragt, der eine Sekunde braucht, um die „Temperatur“ einer Stadt zurückzugeben:

// HttpClient: asynchrone HTTP-Anfragen (sendAsync + await) oder blockierende (send auf dem IO-Dispatcher)
// an einen kleinen lokalen HTTP-Server
package async22

import com.sun.net.httpserver.HttpServer
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.future.await
import kotlinx.coroutines.runBlocking
import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.URI
import java.net.URLDecoder
import java.net.URLEncoder
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.util.concurrent.Executors

const val PORT = 27510
val cities = listOf("Angers", "Brest", "Colmar", "Dijon", "Évry", "Foix")
var start = System.nanoTime()

fun main() = runBlocking {
    // ein HTTP-Server, der eine Sekunde braucht, um die "Temperatur" einer Stadt zu liefern
    val server = HttpServer.create(InetSocketAddress(InetAddress.getLoopbackAddress(), PORT), 0)
    server.createContext("/temperature") { exchange ->
        // die Anfrage hat die Form /temperature?city=xxx
        val city = URLDecoder.decode(exchange.requestURI.rawQuery.removePrefix("city="), Charsets.UTF_8)
        Thread.sleep(1000)
        val response = "$city : ${10 + city.length} °C".toByteArray()
        exchange.sendResponseHeaders(200, response.size.toLong())
        exchange.responseBody.use { it.write(response) }
    }
    // jede empfangene Anfrage wird von einem virtuellen Thread verarbeitet
    server.executor = Executors.newVirtualThreadPerTaskExecutor()
    server.start()

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

            // 1 - eine Coroutine pro Stadt; jede wird bis zu ihrer Antwort ausgesetzt
            start = System.nanoTime()
            val responses = cities.map { city -> async { readTemperature(client, city) } }.awaitAll()
            display("1 - sendAsync + await: $responses")

            // 2 - send ist blockierend: es wird vom IO-Dispatcher aus aufgerufen
            start = System.nanoTime()
            val responses2 = cities.map { city ->
                async(Dispatchers.IO) {
                    client.send(request(city), HttpResponse.BodyHandlers.ofString()).body()
                }
            }.awaitAll()
            display("2 - send on the IO dispatcher: $responses2")
        }
    } finally {
        server.stop(0)
    }
}

// die Temperatur einer Stadt: sendAsync gibt ein CompletableFuture zurück,
// await() setzt die Coroutine bis zur Antwort aus, ohne einen Thread zu blockieren
suspend fun readTemperature(client: HttpClient, city: String): String =
    client.sendAsync(request(city), HttpResponse.BodyHandlers.ofString()).await().body()

// die GET-Anfrage, die die Temperatur einer Stadt abfragt
fun request(city: String): HttpRequest {
    val parameter = URLEncoder.encode(city, Charsets.UTF_8)
    return HttpRequest.newBuilder(URI.create("http://localhost:$PORT/temperature?city=$parameter")).build()
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) =
    println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

1
2
3
> gradlew -q run -Pmain=async22.Async22Kt
 1056 ms : 1 - sendAsync + await: [Angers : 16 °C, Brest : 15 °C, Colmar : 16 °C, Dijon : 15 °C, Évry : 14 °C, Foix : 14 °C]
 1047 ms : 2 - send on the IO dispatcher: [Angers : 16 °C, Brest : 15 °C, Colmar : 16 °C, Dijon : 15 °C, Évry : 14 °C, Foix : 14 °C]

Erläuterungen:

  • Zeilen 26–38: der Server. Die JVM enthält einen kleinen HTTP-Server, nämlich die Klasse [HttpServer] des Moduls [jdk.httpserver] (Paket [com.sun.net.httpserver]). Er wird an der lokalen Adresse ([getLoopbackAddress()]) und am Port 27510 erstellt; [createContext] ordnet dem Pfad [/temperature] einen Handler zu – ein Lambda, das den HTTP-Austausch empfängt (das Java-Interface [HttpHandler] hat nur eine Methode: Das Kotlin-Lambda wird in dieses umgewandelt; dies ist eine SAM-Konvertierung, Kapitel 7). Der Handler dekodiert den Parameter [city] aus der angeforderten Adresse ([removePrefix] entfernt den vorangestellten Teil [city=]), wartet eine Sekunde und sendet dann die Antwort; [toByteArray()] kodiert die Zeichenkette als UTF-8. In Zeile 37 wird jede Anfrage von einem virtuellen Thread verarbeitet: Ein so konfigurierter Server kann Tausende wartender Clients bedienen. Beachten Sie die Schreibweise [server.executor = …]: Kotlin stellt das Paar von Java-Methoden [getExecutor] / [setExecutor] als Eigenschaft dar, ebenso wie [getRequestURI()] zu [requestURI] und [getResponseBody()] zu [responseBody] wird;
  • Zeile 41: Der Client wird über einen Konstruktor ([newBuilder]) erstellt, der hier die Protokollversion festlegt. Ab Java 21 implementiert er [AutoCloseable]: Die Funktion [use] schließt ihn am Ende des Blocks. Eine erste Anfrage dient dazu, die JVM „aufzuwärmen“: Die erste Verwendung eines Clients lädt zahlreiche Klassen, die die nachfolgende Messung um einige hundert Millisekunden verfälschen würden;
  • Zeilen 64–67: die Suspend-Funktion [readTemperature]. [sendAsync(request, handler)] sendet die Anfrage und gibt sofort ein [CompletableFuture<HttpResponse<String>>] zurück; der Body-Handler [BodyHandlers.ofString()] legt fest, dass der Antwortrumpf als Zeichenkette gelesen werden soll. [await()] suspendiert die Coroutine, bis die Antwort eintrifft, und der Rumpf wird abgerufen ([body()]). Wo das Java-Programm eine Fortsetzung verkettete ([thenApply(HttpResponse::body)]), schreiben wir die Aufrufe einfach nacheinander;
  • Zeilen 45–48: Sechs Coroutinen, eine pro Stadt, senden ihre Anfragen gleichzeitig; ihre Antworten treffen gemeinsam nach einer Sekunde ein (Zeile 2 der Ergebnisse). Während der Wartezeit wartet kein Thread auf die Antwort: Der Client überwacht seine Verbindungen mit einem „Selector“-Thread, der das [CompletableFuture] beendet; die Fortsetzung der Coroutinen übernimmt dann der Dispatcher von [runBlocking], das heißt der Hauptthread. Das Java-Programm musste die [CompletableFuture]-Objekte mit [allOf] kombinieren und anschließend ihre Ergebnisse mit [resultNow] lesen; [awaitAll()] erledigt beides;
  • Zeilen 50–57: [send] blockiert; es wird von sechs Coroutinen aufgerufen, die auf dem Dispatcher [IO] laufen und von denen jede während des Wartens einen Thread belegt. Das Ergebnis ist dasselbe: eine Sekunde für die sechs Anfragen (Zeile 3). Dieser Ansatz funktioniert bei einigen wenigen Anfragen; bei Tausenden von Anfragen belegen [sendAsync] und [await()] während des Wartens keine Threads;
  • Zeilen 59–60: Der Server wird am Ende des Programms heruntergefahren, unabhängig vom Ergebnis; der Parameter von [stop] ist die Anzahl der Sekunden, die laufenden Transaktionen zum Abschluss zur Verfügung stehen;
  • Zeilen 70–72: 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];
  • die Variable [start] (Zeile 23) ist eine veränderbare Variable auf oberster Ebene ([var]), die vor jeder Messung auf die aktuelle Zeit zurückgesetzt wird; die Funktion [display] zeigt die seit [start] verstrichene Zeit an, wie in den vorherigen Programmen.

Merken Sie sich die folgende Regel: Bei einer Java-API, die ein CompletableFuture zurückgibt, wartet eine Coroutine mit await()** darauf; bei einer blockierenden API ruft sie diese auf dem [IO]-Dispatcher auf. In beiden Fällen bleibt der Code der Coroutine sequenziell.

9.10. Asynchrone Wertflüsse

Eine asynchrone Operation gibt nach einer gewissen Zeit ein Ergebnis zurück. Eine Sequenz ([Sequence], Kapitel 5) oder ein Iterator gibt eine Folge von Werten zurück, die bei Bedarf erzeugt werden. Manchmal müssen beide kombiniert werden: eine Folge von Werten, bei der jeder Wert vor seiner Erzeugung eine Wartezeit erfordert. 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 Sensormesswerten und so weiter. Der Java-Kurs stellte zwei Modelle vor: das „Pull“-Modell, bei dem der Verbraucher den nächsten Wert anfordert und auf dessen Eintreffen wartet (ein [Stream] , bei dem jeder Wert blockiert und von einem virtuellen Thread gelesen wird), und das „Push“-Modell, bei dem der Erzeuger Werte an seine Abonnenten sendet, die den Durchsatz steuern (die Schnittstellen [java.util.concurrent.Flow] in Java 9 und die Klasse [SubmissionPublisher]).

Kotlinx.coroutines bietet zwei Werkzeuge, die diese beiden Modelle abdecken:

  • den Stream ([Flow<T>], Paket [kotlinx.coroutines.flow]): eine Folge von Werten, die von einer Suspend-Funktion auf Anforderung des Verbrauchers erzeugt wird. Er ist das asynchrone Gegenstück zu einer Sequenz, mit Operatoren ([map], [filter], [take] …), die selbst Suspend-Funktionen sind. Ein Stream ist passiv: Es wird nichts erzeugt, bis jemand ihn sammelt, und jedes Sammeln startet die Erzeugung neu;
  • den Channel ([Channel<T>]), dem wir bereits im Programm [Async14.kt] begegnet sind: eine Warteschlange zwischen Coroutinen, in die der Erzeuger sendet ([send]) und aus der der Verbraucher empfängt ([receive]); beide werden suspendiert, wenn der andere nicht mithalten kann. Ein Channel ist „heiß“: Der Erzeuger arbeitet unabhängig vom Verbraucher. Auch geteilte Streams ([SharedFlow], [StateFlow]) sind heiß.

C# bietet für denselben Zweck die asynchronen Datenflüsse [IAsyncEnumerable<T>], die mit [yield return] erzeugt und mit [await foreach] konsumiert werden: Das Kotlin-Gegenstück ist [Flow].

9.10.1. Flows

Ein Stream wird mit der Funktion [flow { … }] erstellt, deren Block eine Suspend-Funktion ist, die ihre Werte ausgibt, und zwar mit [emit(value)]; konsumiert wird er mit der Suspend-Funktion [collect { value -> … }], die ihren Block für jeden ausgegebenen Wert ausführt. Das Programm [Async23.kt] übernimmt das Java-Programm, das Messwerte erzeugte – einen alle 200 ms –, in Form eines [Stream<Measurement>]:

// eine Folge von Werten, die mit Wartezeiten erzeugt werden: ein Flow von kotlinx.coroutines (Flow)
package async23

import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.flow.take
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import java.text.NumberFormat

var start = System.nanoTime()

fun main() = runBlocking {
    // 1 - jeder Wert wird verarbeitet, sobald er erzeugt wird
    start = System.nanoTime()
    readMeasurements("sensor-1", 4).collect { measurement -> display("1 - received $measurement") }

    // 2 - die Sammlung kann vor dem Ende gestoppt werden: der Producer erzeugt die folgenden Werte nicht
    start = System.nanoTime()
    val hot = readMeasurements("sensor-2", 100)
        .onEach { measurement -> display("2 - received $measurement") }
        .first { measurement -> measurement.value >= 22 }
    display("2 - first measurement of at least 22 °C: $hot")

    // 3 - Abbruch: die Coroutine, die den Flow sammelt, wird nach 700 ms abgebrochen
    start = System.nanoTime()
    val reader = launch {
        try {
            readMeasurements("sensor-3", 100).collect { measurement -> display("3 - received $measurement") }
        } catch (e: CancellationException) {
            display("3 - reading cancelled")
            throw e
        }
    }
    delay(700)
    reader.cancelAndJoin()

    // 4 - Operatoren transformieren den Flow: Filtern, Transformation, Begrenzung
    start = System.nanoTime()
    val high = readMeasurements("sensor-4", 100)
        .filter { measurement -> measurement.value > 21 }
        .map { measurement -> format(measurement.value) }
        .take(4)
        .toList()
    display("4 - measurements greater than 21: ${high.joinToString(" ; ", "[", "]")}")
}

// ein Producer: eine Messung alle 200 ms, nur erzeugt, wenn der Collector sie anfordert
fun readMeasurements(sensor: String, count: Int): Flow<Measurement> = flow {
    try {
        for (i in 1..count) {
            // Warten auf die nächste Messung
            delay(200)
            // emit setzt den Producer aus, bis der Collector den Wert verarbeitet hat
            emit(Measurement(sensor, i, 19.5 + i * 0.75))
        }
    } finally {
        // wird am normalen Ende ausgeführt, nach dem Stoppen der Sammlung oder bei Abbruch
        println("          $sensor: end of production")
    }
}

// eine Messung
data class Measurement(val sensor: String, val number: Int, val value: Double) {
    override fun toString() = "$sensor no. $number : ${format(value)} °C"
}

// eine reelle Zahl im Format der Sprache des Rechners, ohne unnötige Nachkommastellen
fun format(value: Double): String = NumberFormat.getInstance().format(value)

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) =
    println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async23.Async23Kt
  413 ms : 1 - received sensor-1 no. 1 : 20.25 °C
  615 ms : 1 - received sensor-1 no. 2 : 21 °C
  816 ms : 1 - received sensor-1 no. 3 : 21.75 °C
 1020 ms : 1 - received sensor-1 no. 4 : 22.5 °C
          sensor-1: end of production
  241 ms : 2 - received sensor-2 no. 1 : 20.25 °C
  451 ms : 2 - received sensor-2 no. 2 : 21 °C
  652 ms : 2 - received sensor-2 no. 3 : 21.75 °C
  859 ms : 2 - received sensor-2 no. 4 : 22.5 °C
          sensor-2: end of production
  864 ms : 2 - first measurement of at least 22 °C: sensor-2 no. 4 : 22.5 °C
  242 ms : 3 - received sensor-3 no. 1 : 20.25 °C
  450 ms : 3 - received sensor-3 no. 2 : 21 °C
  651 ms : 3 - received sensor-3 no. 3 : 21.75 °C
          sensor-3: end of production
  744 ms : 3 - reading cancelled
          sensor-4: end of production
 1262 ms : 4 - measurements greater than 21: [21.75 ; 22.5 ; 23.25 ; 24]

Erläuterungen:

  • Zeilen 57–67: der Erzeuger. Die Funktion [readMeasurements] ist keine blockierende Funktion: Sie gibt sofort einen [Flow<Measurement>] zurück, ohne etwas zu erzeugen. Der Block von [flow] wird erst ausgeführt, wenn ein Verbraucher den Stream sammelt. Er wartet 200 ms mit [delay] und sendet dann einen Messwert mit [emit]; [emit] ist eine Suspend-Funktion, die den [collect]-Block des Verbrauchers aufruft und die Kontrolle erst zurückgibt, wenn der Wert verarbeitet wurde: Jeder Messwert wird verarbeitet, bevor der nächste erzeugt wird. Der [finally]-Block ist das „[finally] des Erzeugers“: Er ersetzt die Aktion [onClose] des Java-Blocks von [Stream] und wird ausgeführt, unabhängig davon, wie das Sammeln endet;
  • Zeile 24: Jeder Messwert wird verarbeitet, sobald er erzeugt wurde: einer alle 200 ms (Zeilen 2–5 der Ergebnisse; der erste trifft etwas später ein, während die JVM die Stream-Klassen lädt), dann endet der Erzeuger (Zeile 6). Es müssen keine Streams geschlossen werden: Das Ende des Sammelns der Daten markiert das Ende der Erzeugung;
  • Zeilen 26–31: Der Operator [onEach] führt für jeden durchlaufenden Wert eine Aktion aus, und die Suspend-Funktion [first { condition }] sammelt den Stream bis zum ersten Wert, der die Bedingung erfüllt, gibt ihn zurück und beendet das Sammeln. Der Erzeuger produziert die restlichen 96 Messwerte nicht: Sein [emit] hat eine interne Abbruchausnahme ausgelöst, die ihn unterbrochen und sein [finally] ausgeführt hat (Zeile 11 der Ergebnisse). Um dasselbe Ergebnis zu erzielen, musste das Java-Programm den Stream mit seinem Iterator durchlaufen und ihn über [break] verlassen;
  • Zeilen 33–44: der Abbruch. Der Stream wird von einer anderen Coroutine gesammelt, die die Haupt-Coroutine nach 700 ms mit [cancelAndJoin()] abbricht. Das [delay] des vierten Messwerts wird abgebrochen: Es löst eine [CancellationException] aus, die den Erzeuger durchläuft (sein [finally] wird ausgeführt, Zeile 16 der Ergebnisse), dann [collect], und schließlich beim [catch] des Lesers ankommt (Zeile 17), der sie wie erwartet erneut auslöst. Eine Thread-Unterbrechung ist nicht nötig: Dies ist der kooperative Abbruch von Coroutinen.
  • Zeilen 46–53: Die Operatoren [filter], [map] und [take] transformieren den Stream und geben einen neuen Stream zurück; sie sind nach den Funktionen für Collections und Sequenzen benannt (Kapitel 5). Die Suspend-Funktion [toList()] sammelt den Stream in einer Liste. [take(4)] beendet das Sammeln nach vier Werten: Der Erzeuger, der auf 100 Messwerte eingestellt ist, stoppt beim sechsten (das Ergebnis liegt nach etwa 6 × 200 ms vor). Das Java-Programm sammelte sechs Messwerte und filterte sie; hier könnte der Stream unendlich sein;
  • Zeilen 72–77: Die Methode [toString] der Datenklasse [Measurement] wird für eine kompaktere Anzeige neu definiert; [NumberFormat.getInstance()] formatiert die reelle Zahl gemäß der Sprache des Rechners, ohne unnötige Nachkommastellen ([21], [21.75]).

Es ist wichtig, die beiden Arten von Funktionen in der Stream-API zu unterscheiden:

  • Intermediäre Operatoren ([map], [filter], [take], [onEach], [flowOn], [buffer], [catch] …) sind keine Suspend-Funktionen: Sie geben sofort einen neuen Stream zurück, der einen Vorgang beschreibt, ohne etwas auszuführen;
  • terminale Operatoren ([collect], [toList], [first], [single], [reduce], [fold], [count] …) sind Suspend-Funktionen: Sie lösen die Erzeugung aus und warten auf deren Ende.

Dies ist das Modell der Kotlin-Sequenzen (und des Java-[Stream]), aber jeder Schritt kann nun warten, ohne einen Thread zu blockieren. Das Programm [Async20.kt] meldete den Fortschritt einer Operation über eine Callback-Funktion; eine Operation kann auch einen [Flow<Progress>] zurückgeben und ihren Fortschritt in Echtzeit melden, wobei der Aufrufer diese Meldungen mit [collect] sammelt.

9.10.2. Kalte Streams, flowOn, buffer und catch

Das Programm [Async24.kt] demonstriert vier Eigenschaften von Streams: Sie sind kalt, ihr Erzeuger kann den Dispatcher wechseln, ein Puffer kann den Erzeuger vom Verbraucher entkoppeln, und Ausnahmen im vorgelagerten Teil lassen sich abfangen:

// Flows (Flow) sind cold; flowOn, buffer und catch
package async24

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.buffer
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.runBlocking
import kotlin.time.measureTime

var start = System.nanoTime()

fun main() = runBlocking {
    // 1 - ein Flow ist cold: seine Erstellung erzeugt nichts; jede Sammlung startet die Produktion neu
    start = System.nanoTime()
    val values = counter("A", 3)
    display("1 - flow created")
    display("1 - 1st collection: ${values.toList()}")
    display("1 - 2nd collection: ${values.toList()}")

    // 2 - flowOn: der Producer (und was vor flowOn steht) läuft auf einem anderen Dispatcher
    start = System.nanoTime()
    counter("B", 2)
        .map { value -> "$value (transformed by ${threadName()})" }
        .flowOn(Dispatchers.Default)
        .collect { value -> display("2 - received $value, collected by ${threadName()}") }

    // 3 - ohne Puffer: Produktion (200 ms) und Verarbeitung (300 ms) folgen aufeinander
    val withoutBuffer = measureTime {
        counter("C", 5, trace = false).collect { delay(300) }
    }
    println("3 - without a buffer: ${withoutBuffer.inWholeMilliseconds} ms")
    // mit Puffer: der Producer arbeitet, während der Collector verarbeitet
    val withBuffer = measureTime {
        counter("D", 5, trace = false).buffer().collect { delay(300) }
    }
    println("3 - with a buffer: ${withBuffer.inWholeMilliseconds} ms")

    // 4 - catch fängt die Exceptions des Upstreams ab und kann einen Ersatzwert emittieren
    start = System.nanoTime()
    readings()
        .onEach { value -> display("4 - received $value") }
        .catch { e ->
            display("4 - error caught: ${e.message}")
            emit(-1)
        }
        .collect { value -> display("4 - collected $value") }
}

// ein Flow von [count] ganzen Zahlen, eine alle 200 ms
fun counter(name: String, count: Int, trace: Boolean = true): Flow<Int> = flow {
    if (trace) display("    $name: start of production, by ${threadName()}")
    for (i in 1..count) {
        delay(200)
        emit(i)
    }
}

// ein Flow, der nach zwei Werten fehlschlägt
fun readings(): Flow<Int> = flow {
    emit(10)
    emit(20)
    throw IllegalStateException("sensor unplugged")
}

fun threadName(): String = Thread.currentThread().name

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) =
    println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async24.Async24Kt
    3 ms : 1 - flow created
   45 ms :     A: start of production, by main
  673 ms : 1 - 1st collection: [1, 2, 3]
  673 ms :     A: start of production, by main
 1275 ms : 1 - 2nd collection: [1, 2, 3]
   37 ms :     B: start of production, by DefaultDispatcher-worker-1
  247 ms : 2 - received 1 (transformed by DefaultDispatcher-worker-1), collected by main
  448 ms : 2 - received 2 (transformed by DefaultDispatcher-worker-1), collected by main
3 - without a buffer: 2513 ms
3 - with a buffer: 1712 ms
   26 ms : 4 - received 10
   27 ms : 4 - collected 10
   27 ms : 4 - received 20
   27 ms : 4 - collected 20
   27 ms : 4 - error caught: sensor unplugged
   27 ms : 4 - collected -1

Erläuterungen:

  • Zeilen 57–61: der Test-Stream: eine ganze Zahl alle 200 ms. Der Parameter [trace] (Standardwert [true]) zeigt den Beginn der Erzeugung und den ausführenden Thread an;
  • Zeilen 20–25: Das Erstellen des Streams erzeugt nichts (Zeile 2 der Ergebnisse: keine Spur des Erzeugers). Jedes Sammeln ([toList()]) führt den Block von [flow] von Anfang an erneut aus (Zeilen 3 und 5): Ein Stream ist ein Rezept für die Erzeugung, keine Quelle bereits unterwegs befindlicher Werte. Das ist der Unterschied zu einem Channel, der später behandelt wird;
  • Zeilen 27–32: Standardmäßig läuft der Erzeuger in der Coroutine des Sammlers, auf dessen Dispatcher: Zeile 3 der Ergebnisse zeigt, dass der Erzeuger aus Teil 1 auf dem [main]-Thread lief. Der Operator [flowOn(dispatcher)] bewirkt, dass alles, was ihm vorausgeht (der Erzeuger und [map]), auf einem anderen Dispatcher läuft, hier [Dispatchers.Default], während das Sammeln auf dem [main]-Thread bleibt (Zeilen 7–9). Dies ist das Werkzeug für grafische Anwendungen: Die Erzeugung (Lesen aus einer Datenbank oder dem Netzwerk) erfolgt auf [Dispatchers.IO] oder [Default], während das Sammeln der Daten (die Anzeige) auf dem Oberflächen-Thread erfolgt. Sie dürfen den Dispatcher niemals im Block von [flow] mit [withContext] um ein [emit] herum wechseln: Die Bibliothek erkennt dies und löst eine [IllegalStateException] aus; [flowOn] ist der einzig richtige Weg;
  • Zeilen 34–43: Ohne Puffer wartet [emit] darauf, dass der Sammler den Wert verarbeitet: Erzeugung (200 ms) und Verarbeitung (300 ms) erfolgen nacheinander, und die fünf Werte benötigen 5 × 500 = 2.500 ms (Zeile 10 der Ergebnisse). Der Operator [buffer()] setzt einen Channel zwischen Erzeuger und Sammler, die dann in zwei verschiedenen Coroutinen laufen: Der Erzeuger bereitet den nächsten Wert vor, während der Sammler den vorherigen verarbeitet, und der gesamte Vorgang dauert 200 + 5 × 300 = 1.700 ms (Zeile 11). Die Funktion [measureTime] der Standardbibliothek misst die Dauer eines Blocks. Der Puffer hat eine Kapazität (standardmäßig 64 Werte; mit [buffer(10)] legen Sie einen anderen Wert fest): Ist er voll, wird der Erzeuger suspendiert, bis ein Platz frei wird. Dies ist der Gegendruck (Backpressure) reaktiver Streams, erreicht ohne jedes Anforderungsprotokoll: Ein suspendierter Erzeuger erzeugt nichts mehr;
  • Zeilen 66–69: ein Stream, der nach zwei Werten fehlschlägt;
  • Zeilen 45–53: Der Operator [catch] fängt Ausnahmen ab, die vorgelagert ausgelöst werden (vom Erzeuger und von vorangehenden Operatoren, hier [onEach]). Sein Block erhält die Ausnahme und kann sie anzeigen, Ersatzwerte zurückgeben (hier [-1], Zeile 17 der Ergebnisse) oder eine andere Ausnahme auslösen. Nachgelagerte Ausnahmen (die aus dem [collect]-Block) fängt er nicht ab: Dafür wird das Sammeln in ein gewöhnliches [try / catch] eingeschlossen, das auch vorgelagerte Ausnahmen abfängt. Anders als ein [catch (e: Exception)] lässt der Operator [catch] die Abbruchausnahme der Coroutine, die den Stream sammelt, passieren: Er verhindert den Abbruch nicht.

Weitere Operatoren sind oft nützlich: [transform] (null, einen oder mehrere Werte für jeden empfangenen Wert ausgeben), [onCompletion] (eine Aktion am Ende des Streams, gegebenenfalls mit ihrer Ursache), [retry] (die Erzeugung nach einem Fehler wieder aufnehmen), [distinctUntilChanged] (einen Wert ignorieren, der dem vorherigen gleicht), [conflate] (ein langsamer Sammler erhält nur den jeweils jüngsten Wert), [scan] (aufeinanderfolgende Ergebnisse einer Akkumulation), [combine] und [zip] (zwei Streams kombinieren).

9.10.3. Channels: ein Erzeuger, ein Verbraucher

Ein Stream ist „kalt“: Seine Erzeugung liegt in der Verantwortung des Verbrauchers. Wenn die Quelle in ihrem eigenen Tempo produziert, unabhängig davon, ob gelesen wird oder nicht (ein Sensor, empfangene Nachrichten, Ereignisse), ist ein „heißer“ Stream erforderlich. Der einfachste ist der Channel ([Channel<T>], Paket [kotlinx.coroutines.channels]), eine Warteschlange für Coroutinen: Er ist das Gegenstück zu einer [BlockingQueue] (Kapitel 8), bei der die Operationen, die den Thread blockierten ([put], [take]), zu Suspend-Funktionen werden ([send], [receive]). Seine Kapazität wird bei der Erstellung festgelegt:

  • [Channel<T>()] ([Channel.RENDEZVOUS]): kein Puffer; jedes [send] wartet auf ein [receive] (Programm [Async14.kt]);
  • [Channel<T>(n)]: ein Puffer mit [n] Werten; [send] wartet nur, wenn der Puffer voll ist;
  • [Channel<T>(Channel.UNLIMITED)]: ein unbegrenzter Puffer; [send] wartet nie (mit dem Risiko, dass der Speicher volläuft);
  • [Channel<T>(Channel.CONFLATED)]: ein einziger Platz; ein neuer Wert ersetzt den noch nicht gelesenen.

Das Programm [Async25.kt] lässt einen langsamen Verbraucher die Messwerte eines Erzeugers lesen, der startet, ohne auf ihn zu warten:

// ein Channel (Channel) zwischen einem Producer und einem Consumer: ein Hot Flow mit Puffer
package async25

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import java.text.NumberFormat

var start = System.nanoTime()

fun main() = runBlocking {
    // 1 - der Producer startet sofort, ob jemand den Channel liest oder nicht
    start = System.nanoTime()
    val measurements = produceMeasurements("sensor-1", 5)
    delay(700)
    display("consumer: start of reading")
    // die for-Schleife empfängt die Werte einzeln, bis der Channel geschlossen wird
    for (measurement in measurements) {
        display("consumer: received $measurement")
        // der Consumer ist langsamer als der Producer
        delay(500)
    }
    display("1 - the channel is closed: end of reading")

    // 2 - der Consumer hört auf zu lesen: cancel() schließt den Channel, der Producer stoppt
    start = System.nanoTime()
    val measurements2 = produceMeasurements("sensor-2", 100)
    repeat(2) { display("2 - received ${measurements2.receive()}") }
    measurements2.cancel()
    display("2 - reading abandoned")
}

// startet einen Producer im Scope des Aufrufers und gibt den Channel zurück, in den er seine Messungen sendet
fun CoroutineScope.produceMeasurements(sensor: String, count: Int): ReceiveChannel<Measurement> {
    // ein Channel, der 2 gesendete, aber noch nicht empfangene Werte enthalten kann
    val channel = Channel<Measurement>(capacity = 2)
    launch {
        try {
            for (i in 1..count) {
                delay(200)
                // send setzt den Producer aus, solange der Puffer voll ist
                channel.send(Measurement(sensor, i, 19.5 + i * 0.75))
                display("    producer: measurement no. $i sent")
            }
        } finally {
            // das Schließen signalisiert dem Consumer, dass keine Werte mehr kommen
            channel.close()
            display("    producer: end of production")
        }
    }
    return channel
}

// eine Messung
data class Measurement(val sensor: String, val number: Int, val value: Double) {
    override fun toString() = "$sensor no. $number : ${NumberFormat.getInstance().format(value)} °C"
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) =
    println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async25.Async25Kt
  232 ms :     producer: measurement no. 1 sent
  501 ms :     producer: measurement no. 2 sent
  715 ms : consumer: start of reading
  739 ms : consumer: received sensor-1 no. 1 : 20.25 °C
  739 ms :     producer: measurement no. 3 sent
 1240 ms : consumer: received sensor-1 no. 2 : 21 °C
 1240 ms :     producer: measurement no. 4 sent
 1740 ms : consumer: received sensor-1 no. 3 : 21.75 °C
 1741 ms :     producer: measurement no. 5 sent
 1743 ms :     producer: end of production
 2261 ms : consumer: received sensor-1 no. 4 : 22.5 °C
 2762 ms : consumer: received sensor-1 no. 5 : 23.25 °C
 3263 ms : 1 - the channel is closed: end of reading
  202 ms :     producer: measurement no. 1 sent
  206 ms : 2 - received sensor-2 no. 1 : 20.25 °C
  409 ms :     producer: measurement no. 2 sent
  409 ms : 2 - received sensor-2 no. 2 : 21 °C
  419 ms : 2 - reading abandoned
  614 ms :     producer: end of production

Erläuterungen:

  • Zeilen 37–54: der Erzeuger. Die Funktion [produceMeasurements] ist eine Erweiterung von [CoroutineScope]: Sie startet eine Coroutine im Gültigkeitsbereich des Aufrufers ([launch] wirkt auf den impliziten Empfänger [this], den Gültigkeitsbereich) und gibt sofort den Channel zurück, an den diese Coroutine ihre Messwerte senden wird. Dies ist die Konvention von kotlinx.coroutines: Eine Funktion, die Coroutinen startet und zurückkehrt, ohne auf sie zu warten, ist eine Erweiterung von CoroutineScope; eine Funktion, die auf den Abschluss ihrer Arbeit wartet, ist eine Suspend-Funktion. Der zurückgegebene Typ [ReceiveChannel<Measurement>] ist der „Empfangs“-Teil des Channels: Der Aufrufer kann nur empfangen;
  • Zeile 39: ein Channel mit einer Kapazität von 2;
  • Zeile 45: [send] legt den Messwert im Puffer ab oder suspendiert den Erzeuger, wenn dieser voll ist;
  • Zeilen 49–50: Am Ende der Erzeugung – ob normal oder nicht – schließt der Erzeuger den Channel. Das Schließen des Channels löscht die Werte im Puffer nicht: Der Verbraucher erhält sie weiterhin und erfährt anschließend, dass der Channel geschlossen ist;
  • Zeilen 17–19: Der Erzeuger startet sofort, während der Verbraucher den Channel erst 700 ms später liest. In dieser Zeit füllen die Messwerte Nr. 1 und Nr. 2 den Puffer (Zeilen 2–3 der Ergebnisse); Messwert Nr. 3, der etwa bei 600 ms bereit ist, kann nicht abgelegt werden: [send] suspendiert den Erzeuger. Sobald der Verbraucher Messwert Nr. 1 empfängt, wird ein Platz frei, und Messwert Nr. 3 wird abgelegt (Zeilen 5–6). Anschließend hält der Erzeuger mit dem Verbraucher Schritt und sendet alle 500 ms einen Messwert: Das ist der Gegendruck, der einfach durch das Suspendieren von [send] erreicht wird;
  • Zeilen 21–26: Ein Channel wird mit einer [for]-Schleife verarbeitet, die die Werte einzeln empfängt und endet, wenn der Channel geschlossen und leer ist. Der Erzeuger war bei 1.743 ms fertig (Zeile 11 der Ergebnisse); der Verbraucher liest noch die beiden Messwerte aus dem Puffer (Zeilen 12–13), bevor er die Schleife verlässt (Zeile 14);
  • Zeilen 28–33: [receive()] empfängt jeweils einen Wert; nach zwei Messwerten hört der Verbraucher mit [cancel()] auf zu lesen, wodurch der Channel geschlossen und sein Puffer geleert wird. Das nächste [send] des Erzeugers löst dann eine [CancellationException] aus, die seine Coroutine beendet, nachdem [finally] ausgeführt wurde (letzte Zeile der Ergebnisse). Ohne dieses [cancel()] würde der Erzeuger – durch einen vollen Puffer blockiert – nie enden, und [runBlocking], das auf seine Kinder wartet, ebenso wenig. Sie können einen Channel auch mit [channel.consumeEach { … }] durchlaufen, was den Channel beim Verlassen des Blocks abbricht, unabhängig vom Grund.

Kotlinx.coroutines stellt eine Funktion [produce] bereit, die das tut, was [produceMeasurements] tut (eine Coroutine starten, die in einen Channel schreibt, und den Channel zurückgeben), die aber noch als experimentell markiert ist: Ihre Verwendung löst diese Warnung aus, sodass mit der Option [allWarningsAsErrors] in unserem Projekt ein Fehler auftritt:

1
2
3
4
error: warnings found and -Werror specified
T.kt:4:13: warning: this declaration needs opt-in. Its usage should be marked with '@kotlinx.coroutines.ExperimentalCoroutinesApi' or '@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)'
    val c = produce(capacity = 2) { send(1); send(2) }
            ^^^^^^^

In diesem Kurs verwenden wir die experimentelle API nicht (sie müsste ausdrücklich mit der Annotation [@OptIn(ExperimentalCoroutinesApi::class)] akzeptiert werden und könnte sich in einer künftigen Version ändern): Der Channel und das von Hand geschriebene [launch] leisten in wenigen Zeilen dasselbe.

Ein Channel liefert jeden Wert an einen einzigen Verbraucher: Lesen mehrere Coroutinen denselben Channel, teilen sie sich die Werte. Das ist genau das, was man braucht, um Arbeit auf Worker zu verteilen (dies sehen wir im Abschnitt über begrenzte Parallelität), nicht aber, um Werte an mehrere Abonnenten zu senden.

9.10.4. Geteilte Streams: mehrere Abonnenten

Um jeden Wert an alle Abonnenten zu senden, bietet kotlinx.coroutines den geteilten Stream: [MutableSharedFlow<T>], über den der Herausgeber mit [emit] sendet, wird von den Abonnenten als [SharedFlow<T>] gesehen, den sie wie jeden anderen Stream sammeln. Er ist das Gegenstück zu dem [SubmissionPublisher] aus dem Java-Kurs, und das Programm [Async26.kt] verwendet dasselbe Beispiel: sechs Messwerte, die an zwei Abonnenten veröffentlicht werden, eine schnelle Anzeige, die sich abmeldet, wenn die Temperatur 22 °C überschreitet, und ein langsames Archiv:

// ein Hot Flow, der an mehrere Abonnenten gesendet wird: MutableSharedFlow (das Äquivalent von SubmissionPublisher)
package async26

import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.takeWhile
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import java.text.NumberFormat

val start = System.nanoTime()

fun main() = runBlocking {
    // jeder emittierte Wert wird an alle Abonnenten geliefert; Puffer von 2 Werten für den langsamsten
    // der Wert null signalisiert das Ende der Veröffentlichung
    val publisher = MutableSharedFlow<Measurement?>(extraBufferCapacity = 2)

    // der Bildschirm, schnell, meldet sich ab, sobald eine Messung 22 °C erreicht
    launch {
        publisher.untilTheEnd().first { measurement ->
            display("  screen: received $measurement")
            measurement.value >= 22
        }
        display("  screen: threshold reached, unsubscribing")
    }
    // das Archiv, langsam, verarbeitet jede Messung in 500 ms
    launch {
        publisher.untilTheEnd().collect { measurement ->
            display("  archive: received $measurement")
            delay(500)
        }
        display("  archive: end of the flow")
    }

    // wir warten, bis die beiden Abonnenten registriert sind: ein Shared Flow behält nichts für Abwesende
    publisher.subscriptionCount.first { count -> count == 2 }
    for (i in 1..6) {
        delay(200)
        // emit setzt den Publisher aus, wenn im Puffer des langsamsten Abonnenten kein Platz mehr ist
        publisher.emit(Measurement("sensor-1", i, 19.5 + i * 0.75))
        display("publisher: measurement no. $i published")
    }
    display("publisher: end of publication")
    publisher.emit(null)
}

// ein Shared Flow endet nie: die Sammlung wird beim Wert null gestoppt
fun Flow<Measurement?>.untilTheEnd(): Flow<Measurement> = takeWhile { it != null }.filterNotNull()

// eine Messung
data class Measurement(val sensor: String, val number: Int, val value: Double) {
    override fun toString() = "$sensor no. $number : ${NumberFormat.getInstance().format(value)} °C"
}

// Anzeige mit der seit Beginn verstrichenen Zeit
fun display(message: String) =
    println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async26.Async26Kt
  443 ms : publisher: measurement no. 1 published
  504 ms :   screen: received sensor-1 no. 1 : 20.25 °C
  505 ms :   archive: received sensor-1 no. 1 : 20.25 °C
  688 ms : publisher: measurement no. 2 published
  688 ms :   screen: received sensor-1 no. 2 : 21 °C
  894 ms : publisher: measurement no. 3 published
  895 ms :   screen: received sensor-1 no. 3 : 21.75 °C
 1005 ms :   archive: received sensor-1 no. 2 : 21 °C
 1096 ms : publisher: measurement no. 4 published
 1096 ms :   screen: received sensor-1 no. 4 : 22.5 °C
 1096 ms :   screen: threshold reached, unsubscribing
 1506 ms :   archive: received sensor-1 no. 3 : 21.75 °C
 1507 ms : publisher: measurement no. 5 published
 2008 ms :   archive: received sensor-1 no. 4 : 22.5 °C
 2008 ms : publisher: measurement no. 6 published
 2008 ms : publisher: end of publication
 2509 ms :   archive: received sensor-1 no. 5 : 23.25 °C
 3010 ms :   archive: received sensor-1 no. 6 : 24 °C
 3511 ms :   archive: end of the flow

Erläuterungen:

  • Zeile 19: der Herausgeber, ein geteilter Stream von Messwerten. Der Parameter [extraBufferCapacity = 2] stattet ihn mit einem Puffer für 2 Werte aus: Der Herausgeber kann dem langsamsten Abonnenten um bis zu 2 Werte voraus sein. Der Werttyp ist [Measurement?]: Der Wert [null] dient dazu, das Ende der Veröffentlichung zu signalisieren;
  • Zeilen 21–27: Die Anzeige ist eine Coroutine, die den Datenstrom bis zum ersten Messwert von mindestens 22 °C mit [first] sammelt (Programm [Async23.kt]): Das Abonnement beginnt mit dem Sammeln der Daten und endet mit ihm. Es gibt kein [onSubscribe], kein [request(1)] und kein [cancel()]: Das gesamte Protokoll des reaktiven Datenstroms besteht darin, Daten zu sammeln und dann aufzuhören;
  • Zeilen 29–35: Das Archiv verarbeitet jeden Messwert in 500 ms. Während dieser Verarbeitung schreitet das Sammeln der Daten nicht voran: Dies regelt den Durchsatz, wie beim [request(1)] des Java-Abonnenten;
  • Zeile 51: Ein geteilter Stream endet nie: Ein Abonnent, der aus ihm sammelt, wartet unbegrenzt auf die nächsten Werte, bis seine Coroutine abgebrochen wird. Es gibt kein Gegenstück zur Methode [close()] des Java-Herausgebers. Um das Ende zu signalisieren, wird ein vorab vereinbarter Wert ausgegeben – hier [null]. Die Erweiterungsfunktion [untilTheEnd] beendet das Sammeln bei diesem Wert ([takeWhile]) und gibt einen [Flow<Measurement>] zurück ([filterNotNull] ändert den Typ der Werte von [Measurement?] zu [Measurement]);
  • Zeile 39: Ein geteilter Feed bewahrt nichts für abwesende Abonnenten auf: Ein Wert, der veröffentlicht wird, wenn niemand abonniert hat, geht verloren (es sei denn, der Feed wird angewiesen, neuen Abonnenten einige davon mit dem Parameter [replay] erneut zuzustellen). Die Eigenschaft [subscriptionCount] ist ein Stream der Abonnentenzahl: Wir warten, bis sie 2 erreicht, bevor wir veröffentlichen. Ohne diese Vorsichtsmaßnahme hätten die beiden von [launch] gestarteten Abonnenten zum Zeitpunkt der ersten Ausstrahlung noch nicht mit dem Sammeln der Daten begonnen;
  • Zeilen 40–47: Der Herausgeber veröffentlicht alle 200 ms einen Messwert. [emit] ist eine Suspend-Funktion: Ist der Puffer des langsamsten Abonnenten voll, wartet sie darauf, dass ein Platz frei wird. Messwert Nr. 5, der bei etwa 1.300 ms bereit ist, wird erst bei 1.507 ms veröffentlicht (Zeile 14 der Ergebnisse), wenn das Archiv Messwert Nr. 3 übernommen hat. Das ist Gegendruck: Der Herausgeber wird auf das Tempo des langsamsten Abonnenten gebremst;
  • Die Ergebnisse entsprechen denen des Java-Programms: Die Anzeige verarbeitet jeden Messwert, sobald er veröffentlicht wird, und meldet sich bei Messwert Nr. 4 ab (Zeilen 11–12), während das Archiv, das 500 ms pro Messwert benötigt, ins Hintertreffen gerät und alle sechs Messwerte erhält, gefolgt vom Ende des Streams (Zeile 20). Das Programm endet, wenn beide Abonnenten fertig sind: Sie sind Kinder von [runBlocking], das auf sie wartet.

Eine besondere Art von geteiltem Stream ist weit verbreitet: der Zustands-Stream ([MutableStateFlow<T>] / [StateFlow<T>]). Er hat stets einen Wert – den aktuellen Wert –, der über seine Eigenschaft [value] ([state.value = "connected"]) gelesen und geändert werden kann; seine Abonnenten erhalten den aktuellen Wert, sobald sie sich anmelden, und danach jeden neuen Wert (ein Wert, der dem vorherigen gleicht, wird nicht ausgegeben, und ein langsamer Abonnent erhält nur den jeweils jüngsten). Dies ist das Werkzeug, das grafische Anwendungen und Android-Anwendungen verwenden, um den Zustand eines Bildschirms darzustellen: Die Geschäftslogik ändert den Zustand, die Benutzeroberfläche sammelt ihn, und der Bildschirm wird bei jeder Änderung neu gezeichnet. Es ist das asynchrone Gegenstück zu den in Kapitel 7 behandelten beobachtbaren Eigenschaften.

Zusammenfassung:

Werkzeug
Verwendung
[Flow] (kalt)
eine Folge von Werten, die bei Bedarf für einen Verbraucher erzeugt werden: Zeilen aus einer Datei, Ergebnisse einer Abfrage, Seiten einer API
[Channel] (heiß)
eine Warteschlange zwischen Coroutinen: Jeder Wert wird von genau einem Verbraucher empfangen (Erzeuger/Verbraucher, Lastverteilung)
[SharedFlow] (heiß)
ein Broadcast: Jeder Wert wird von allen aktuell angemeldeten Abonnenten empfangen (Ereignisse, Nachrichten)
[StateFlow] (heiß)
ein beobachtbarer Zustand: ein aktueller Wert und seine Änderungen

9.11. Cache, Rückkehr zum richtigen Thread und manuelles Beenden der Operation

9.11.1. Ein Cache für asynchrone Operationen

Ein [Deferred] ist, wie ein [CompletableFuture], ein Objekt: Jeder Aufruf einer Funktion, die eines zurückgibt, belegt mindestens ein Objekt auf dem Heap, das der Garbage Collector wieder freigeben muss. Bei E/A-Vorgängen, die Millisekunden dauern, ist das vernachlässigbar. Suspend-Funktionen haben nämlich einen Vorteil gegenüber [CompletableFuture]-Objekten: Eine Suspend-Funktion, die ihr Ergebnis bereits hat, gibt es direkt zurück, ohne die Coroutine zu suspendieren, ohne den Thread zu wechseln und ohne ein [Deferred]-Objekt zu erzeugen; ebenso gibt [await()] auf einem [Deferred], das bereits abgeschlossen ist, seinen Wert zurück, ohne zu suspendieren. Das erreichen andere Sprachen mit einem „leichtgewichtigen“ Typ (zum Beispiel die Struktur [ValueTask] in C#).

Wenn mehrere gleichzeitige Anfragen nach demselben Wert dieselbe laufende Operation gemeinsam nutzen sollen, ist es nach wie vor die beste Praxis, die [Deferred]-Objekte selbst zu cachen: Ein bereits bekannter Wert wird von einem abgeschlossenen [Deferred] geliefert, und ein Wert, der gerade berechnet wird, vom [Deferred] dieser Berechnung. Das Programm [Async27.kt] wendet dies auf den Wechselkursdienst des Java-Programms an:

// ein Cache aus Deferreds: eine asynchrone Operation, die meist bereits das Ergebnis hat
package async27

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.CoroutineStart
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.async
import kotlinx.coroutines.cancel
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import java.math.BigDecimal
import java.text.NumberFormat
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.atomic.AtomicInteger
import kotlin.time.measureTimedValue

fun main() = runBlocking<Unit> {
    RateService().use { service ->
        // 1 - aufeinanderfolgende Lesevorgänge: nur der erste Lesevorgang einer Währung fragt den Server ab
        for (code in listOf("EUR", "USD", "EUR", "EUR", "USD", "GBP", "EUR")) {
            val (rate, duration) = measureTimedValue { service.readRate(code).await() }
            println("%s : %6s read in %3d ms".format(code, format(rate), duration.inWholeMilliseconds))
        }
        println("1 - server accesses: ${service.nbServerAccesses}, reads: ${service.nbReads}")

        // 2 - drei gleichzeitige Lesevorgänge derselben Währung: sie teilen sich dieselbe Operation
        val reads = List(3) { service.readRate("CHF") }
        println("2 - same object: ${reads[0] === reads[2]}, rate: ${format(reads[0].await())}" +
                ", server accesses: ${service.nbServerAccesses}, reads: ${service.nbReads}")

        // 3 - eine fehlgeschlagene Operation wird nicht im Cache behalten
        try {
            service.readRate("XYZ").await()
        } catch (e: IllegalArgumentException) {
            println("3 - ${e.message}, currencies in cache: ${service.currenciesInCache()}")
        }
    }
}

class RateService : AutoCloseable {
    // der Scope der Lesevorgänge: er gehört zum Service, und der Fehlschlag eines Lesevorgangs bricht die anderen nicht ab
    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

    // der Cache enthält die Deferreds selbst, beendet oder in Arbeit
    private val cache = ConcurrentHashMap<String, Deferred<BigDecimal>>()
    private val serverAccesses = AtomicInteger()
    private val reads = AtomicInteger()
    val nbServerAccesses get() = serverAccesses.get()
    val nbReads get() = reads.get()

    fun readRate(code: String): Deferred<BigDecimal> {
        reads.incrementAndGet()
        // ist die Währung im Cache, wird das vorhandene Deferred zurückgegeben: es wird kein Objekt erstellt
        return cache.computeIfAbsent(code, ::readServerRate).also { it.start() }
    }

    // ein Lazy-Lesevorgang: er startet erst mit start(), sobald er im Cache gespeichert ist
    private fun readServerRate(code: String): Deferred<BigDecimal> =
        scope.async(start = CoroutineStart.LAZY) {
            serverAccesses.incrementAndGet()
            try {
                // simuliert die Abfrage eines entfernten Servers (300 ms)
                delay(300)
                when (code) {
                    "EUR" -> BigDecimal.ONE
                    "USD" -> BigDecimal("1.17")
                    "GBP" -> BigDecimal("0.87")
                    "CHF" -> BigDecimal("0.94")
                    else -> throw IllegalArgumentException("unknown currency: $code")
                }
            } catch (e: Exception) {
                // im Fehlerfall wird der Lesevorgang aus dem Cache entfernt: ein späterer Lesevorgang wird neu versucht
                cache.remove(code)
                throw e
            }
        }

    fun currenciesInCache() = cache.keys.sorted()

    // das Schließen des Services bricht die laufenden Lesevorgänge ab
    override fun close() = scope.cancel()
}

// eine reelle Zahl im Format der Sprache des Rechners, ohne unnötige Nachkommastellen
fun format(value: BigDecimal): String = NumberFormat.getInstance().format(value)

Ergebnisse:

> gradlew -q run -Pmain=async27.Async27Kt
EUR :      1 read in 391 ms
USD :   1.17 read in 301 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, reads: 7
2 - same object: true, rate: 0.94, server accesses: 4, reads: 10
3 - unknown currency: XYZ, currencies in cache: [CHF, EUR, GBP, USD]

Erläuterungen:

  • Zeile 44: Der Dienst startet Coroutinen (die Lesevorgänge), die die Coroutine überleben können müssen, die sie angefordert hat: Ein von einem Aufrufer angeforderter Lesevorgang wird mit nachfolgenden Aufrufern geteilt. Sie können daher nicht zum Gültigkeitsbereich eines Aufrufers gehören; sie gehören zu einem eigenen Gültigkeitsbereich des Dienstes – einem Komponenten-Gültigkeitsbereich (Programm [Async16.kt]). Sein [SupervisorJob] stellt sicher, dass der Fehlschlag eines Lesevorgangs die anderen nicht abbricht; sein Dispatcher ist [Dispatchers.Default];
  • Zeile 83: Der Dienst implementiert [AutoCloseable]; sein Schließen bricht den Gültigkeitsbereich und damit alle laufenden Lesevorgänge ab. Das Hauptprogramm verwendet den Dienst in einem [use]-Block (Zeile 20): Keine Coroutine überlebt ihn;
  • Zeile 47: Der Cache ordnet jedem Währungscode das [Deferred] seines Wechselkurses zu, ob abgeschlossen oder noch in Arbeit. Es handelt sich um eine [ConcurrentHashMap] (Kapitel 8), weil sie von mehreren Threads gleichzeitig verwendet werden kann (vom Hauptthread und von den Threads des [Default]-Dispatchers, die die Lesevorgänge ausführen);
  • Zeilen 50–51: Die Zähler sind private [AtomicInteger]-Objekte, die nach außen über zwei schreibgeschützte Eigenschaften bereitgestellt werden, deren Zugriffsmethode [get()] den aktuellen Wert liest (Kapitel 4);
  • Zeilen 53–56: [computeIfAbsent(key, function)] gibt den dem Schlüssel zugeordneten Wert zurück, falls er existiert; andernfalls ruft es die Funktion auf (hier die Referenz [::readServerRate]), speichert deren Ergebnis im Dictionary und gibt es zurück. Bei einer [ConcurrentHashMap] ist diese Operation atomar: Zwei Coroutinen, die gleichzeitig eine nicht vorhandene Währung anfordern, lösen nur einen einzigen Serverzugriff aus. [readRate] ist keine Suspend-Funktion: Sie gibt ein [Deferred] zurück, auf das der Aufrufer mit [await()] wartet, wann immer er möchte;
  • Zeilen 60–61: Der Lesevorgang wird von [async] mit der Option [start = CoroutineStart.LAZY] gestartet: Die Coroutine wird erstellt, startet aber nicht; sie startet beim ersten Aufruf von [start()] oder [await()]. [readRate] startet sie über [.also { it.start() }], nachdem [computeIfAbsent] sie im Cache abgelegt hat ([start()] hat keine Wirkung auf eine Coroutine, die bereits gestartet oder beendet ist). Diese Vorsichtsmaßnahme stellt sicher, dass der Lesevorgang nicht abgeschlossen sein oder versuchen kann, sich selbst aus dem Cache zu entfernen, bevor er dort abgelegt wurde; sie verhindert außerdem, dass innerhalb der Funktion [computeIfAbsent] irgendetwas ausgeführt wird; diese muss kurz sein, da sie läuft, während das Dictionary für diesen Schlüssel gesperrt ist;
  • Zeilen 64–71: die simulierte Serverabfrage (300 ms). Der auf eine Zeichenkette angewendete Ausdruck [when] gibt den Wechselkurs zurück oder löst für eine unbekannte Währung eine Ausnahme aus;
  • Zeilen 73–76: Im Fehlerfall wird die Operation aus dem Cache entfernt, damit eine spätere Anfrage für dieselbe Währung den Server erneut abfragt, statt endlos denselben Fehler zurückzugeben. Das Entfernen erfolgt in der Coroutine, bevor sie endet: Der Aufrufer, der die Ausnahme über [await()] erhält, findet einen bereits aktualisierten Cache vor (das Java-Programm erreichte dieselbe Garantie mit [whenComplete]). Die Ausnahme wird erneut ausgelöst; handelt es sich um eine [CancellationException] (Herunterfahren des Dienstes), wird auch sie erneut ausgelöst, und ein abgebrochener Lesevorgang bleibt ebenfalls nicht im Cache;
  • Zeilen 21–26: Für den Aufrufer ist ein Lesevorgang eine asynchrone Operation wie jede andere: Er wartet mit [await()] darauf. Die Funktion [measureTimedValue] gibt sowohl das Ergebnis des Blocks als auch dessen Dauer zurück, die über eine Destrukturierungszuweisung abgerufen werden. Die Ergebnisse zeigen die 3 Serverzugriffe (je 300 ms; beim ersten etwas länger, während die JVM die erforderlichen Klassen lädt) und die 4 sofortigen Antworten aus dem Cache;
  • Zeilen 28–31: Drei gleichzeitige Anfragen nach dem Wechselkurs des Schweizer Frankens erhalten dasselbe Objekt (der Operator [===] vergleicht die Referenzen) und führen zu nur einem Serverzugriff (Zeile 10 der Ergebnisse);
  • Zeilen 33–37: [await()] löst die Ausnahme des Lesevorgangs erneut aus, die von einem gewöhnlichen [catch] abgefangen wird (das Java-Programm erhielt eine [CompletionException], die die ursprüngliche Ausnahme umhüllte); die unbekannte Währung befindet sich nicht mehr im Cache (Zeile 11). Die Funktion [currenciesInCache] gibt die Schlüssel des Dictionarys sortiert zurück ([sorted()]).

Der [Deferred]-Cache eignet sich, wenn jeder Wert unabhängig von den anderen berechnet wird. Soll dagegen jeweils nur eine Coroutine einen Suspend-Codeabschnitt ausführen dürfen, verwendet man eine Coroutine-Sperre – konkret die Klasse [Mutex] aus dem Paket [kotlinx.coroutines.sync]: [mutex.withLock { … }] führt den Block gegenseitig ausgeschlossen aus, und eine Coroutine, die die Sperre belegt vorfindet, wird suspendiert , ohne ihren Thread zu blockieren. Ein einfacher Cache ließe sich implementieren mit [suspend fun readRate(code: String) = mutex.withLock { cache.getOrPut(code) { readServerRate(code) } }], zusammen mit einer gewöhnlichen [MutableMap], die von der Sperre geschützt wird. Das ist einfacher als der Cache mit [Deferred], bewirkt aber, dass alle Lesevorgänge – auch die einer anderen Währung – bei jedem Serverzugriff warten müssen. Die Sperren aus Kapitel 8 ([synchronized], [ReentrantLock]) sollten Sie nicht um einen Suspend-Aufruf herum verwenden: Sie gehören einem Thread, während eine Coroutine auf einem anderen Thread fortgesetzt werden kann als dem, auf dem sie die Sperre erworben hat ([synchronized] um einen Suspend-Aufruf herum wird vom Compiler tatsächlich abgelehnt).

9.11.2. Rückkehr zum GUI-Thread

Das Programm [Async09.kt] hat gezeigt, dass der Dispatcher entscheidet, welcher Thread eine Coroutine ausführt – und damit, welcher Thread den restlichen Code nach einer Suspendierung ausführt. In einer GUI-Anwendung ist das von Bedeutung: Eine GUI-Komponente darf nur vom GUI-Thread aus bearbeitet werden. Während Java verlangt, dass das Programm die Ausführung selbst auf diesem Thread fortsetzt ([SwingUtilities.invokeLater] bei Swing, [Platform.runLater] bei JavaFX), stellt kotlinx.coroutines einen eigenen Dispatcher bereit, [Dispatchers.Main], dessen Coroutinen auf dem UI-Thread laufen:

  • Er wird von einem Zusatzmodul bereitgestellt, das spezifisch für die jeweilige Grafikbibliothek ist: [kotlinx-coroutines-android] (Android), [kotlinx-coroutines-javafx] (JavaFX), [kotlinx-coroutines-swing] (Swing); ohne dieses Modul löst seine Verwendung eine Ausnahme aus:
java.lang.IllegalStateException: Module with the Main dispatcher is missing. Add dependency providing the Main dispatcher, e.g. 'kotlinx-coroutines-android' and ensure it has the same version as 'kotlinx-coroutines-core'
  • Der Oberflächencode läuft in Coroutinen, die auf [Dispatchers.Main] gestartet werden, und wechselt für die Dauer einer langwierigen Aufgabe auf einen anderen Dispatcher: [val page = withContext(Dispatchers.IO) { download(address) }], dann [textArea.text = page]. Nach [withContext] ist die Coroutine automatisch zum Oberflächen-Thread zurückgekehrt: Es muss nichts angefordert werden. Das ist es, was das C#-[await] in einer grafischen Anwendung tut, indem es die Methode auf dem Oberflächen-Thread fortsetzt;
  • Unter Android stellen Komponenten ihren eigenen, an ihren Lebenszyklus gebundenen Gültigkeitsbereich bereit ([lifecycleScope] für eine Activity, [viewModelScope] für ein ViewModel), dessen Dispatcher [Dispatchers.Main] ist: Wird der Bildschirm zerstört, wird der Gültigkeitsbereich abgebrochen und mit ihm alle Coroutinen, die er gestartet hatte. Dies ist strukturierte Nebenläufigkeit, angewendet auf Oberflächen;
  • Der Sammler eines Streams läuft auf dem Dispatcher der sammelnden Coroutine (dem Thread der Oberfläche), während [flowOn] die Werte anderswo erzeugen lässt (Programm [Async24.kt]). Ein [StateFlow] , der auf [Dispatchers.Main] gesammelt wird, ist der Standardweg, um einen sich ändernden Zustand anzuzeigen.

Die Regel bleibt dieselbe wie im Java-Kurs: Der Oberflächen-Thread darf niemals blockieren ([runBlocking], [Thread.sleep], [join()] auf ein [CompletableFuture], blockierende Ein-/Ausgabe), sonst friert das Fenster ein. Er kann aber so lange suspendieren , wie er will: Eine Coroutine von [Dispatchers.Main] , die auf ein [await()] oder ein [delay] wartet, gibt den Thread an die Grafikbibliothek zurück, die weiter Ereignisse verarbeitet.

9.11.3. Manuelles Beenden einer Operation: CompletableDeferred

Manchmal müssen Sie eine API verwenden, die ihre Ereignisse über Listener meldet (Kapitel 7), während der übrige Code mit Coroutinen geschrieben ist. Kotlinx.coroutines stellt hierfür zwei Werkzeuge bereit:

  • die Klasse [CompletableDeferred<T>], das Gegenstück zu [CompletableFuture], das Sie selbst abschließen: Dies ist ein „ausstehendes“ [Deferred<T>], das Sie sofort weitergeben und später zum passenden Zeitpunkt abschließen, mit [complete(value)] (Erfolg), [completeExceptionally(exception)] (Fehlschlag) oder [cancel()] (Abbruch). Wie bei [CompletableFuture] gewinnt, wer es zuerst abschließt: Spätere Aufrufe haben keine Wirkung ([complete] und [completeExceptionally] geben dann [false] zurück);
  • die Funktion [suspendCancellableCoroutine], die bereits in den Programmen [Async02.kt] und [Async21.kt]verwendet wurde und das erwartete Ereignis in eine abbrechbare Suspend-Funktion umwandelt.

Das Programm [Async28.kt] implementiert das Java-Programm neu, das darauf wartete, dass ein Thermometer – das seine Listener bei jeder Messung benachrichtigt – eine bestimmte Temperatur erreicht:

// eine Operation selbst abschließen: CompletableDeferred, dann suspendCancellableCoroutine,
// um eine Listener-basierte API in eine asynchrone Operation umzuwandeln
package async28

import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.TimeoutCancellationException
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.withTimeout
import kotlinx.coroutines.withTimeoutOrNull
import java.text.NumberFormat
import java.util.concurrent.CopyOnWriteArrayList
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import kotlin.coroutines.resume

val start = System.nanoTime()

fun main() = runBlocking {
    val thermometer = Thermometer()
    thermometer.start()

    // 1 - wir warten auf die erste Messung größer oder gleich 21 °C
    val measurement = awaitTemperature(thermometer, 21.0).await()
    display("1 - temperature reached: ${format(measurement)} °C, listeners: ${thermometer.nbListeners}")

    // 2 - dasselbe Warten, auf 600 ms begrenzt: es ist das Warten, das aufgegeben wird, nicht die Operation
    val waiting = awaitTemperature(thermometer, 30.0)
    val measurement2 = withTimeoutOrNull(600) { waiting.await() }
    display("2 - result: $measurement2, listeners: ${thermometer.nbListeners}")
    // die Operation muss von Hand abgebrochen werden, um den Listener zu entfernen
    waiting.cancel()
    display("2 - after cancel(): listeners: ${thermometer.nbListeners}")

    // 3 - eine abbrechbare suspendierende Funktion: das Timeout bricht die Operation selbst ab
    try {
        withTimeout(600) { temperatureReached(thermometer, 30.0) }
    } catch (e: TimeoutCancellationException) {
        display("3 - 30 °C not reached in 600 ms, listeners: ${thermometer.nbListeners}")
    }
    thermometer.stop()
}

// wandelt die Benachrichtigungen des Thermometers in ein Deferred um, das wir selbst abschließen
fun awaitTemperature(thermometer: Thermometer, threshold: Double): Deferred<Double> {
    val result = CompletableDeferred<Double>()
    // der Listener schließt das Deferred ab, wenn der Schwellenwert erreicht ist
    val listener = { temperature: Double ->
        if (temperature >= threshold) result.complete(temperature)
    }
    thermometer.addListener(listener)
    // egal, wie es endet (Schwellenwert, Fehlschlag, Abbruch): der Listener wird entfernt
    result.invokeOnCompletion { thermometer.removeListener(listener) }
    // das Deferred wird sofort zurückgegeben; es wird später abgeschlossen
    return result
}

// dasselbe als abbrechbare suspendierende Funktion
suspend fun temperatureReached(thermometer: Thermometer, threshold: Double): Double =
    suspendCancellableCoroutine { continuation ->
        lateinit var listener: (Double) -> Unit
        listener = { temperature ->
            if (temperature >= threshold && continuation.isActive) {
                thermometer.removeListener(listener)
                continuation.resume(temperature)
            }
        }
        thermometer.addListener(listener)
        // wird die Coroutine während des Wartens abgebrochen, wird der Listener entfernt
        continuation.invokeOnCancellation { thermometer.removeListener(listener) }
    }

// ein Thermometer, das seine Listener alle 200 ms benachrichtigt (eine API "alten Stils")
class Thermometer {
    private val listeners = CopyOnWriteArrayList<(Double) -> Unit>()
    private val timer = Executors.newSingleThreadScheduledExecutor()
    private var temperature = 19.0
    val nbListeners get() = listeners.size

    fun addListener(listener: (Double) -> Unit) = listeners.add(listener)

    fun removeListener(listener: (Double) -> Unit) = listeners.remove(listener)

    fun start() {
        timer.scheduleAtFixedRate({
            temperature += 0.5
            println("          measurement: ${format(temperature)} °C")
            listeners.forEach { listener -> listener(temperature) }
        }, 200, 200, TimeUnit.MILLISECONDS)
    }

    fun stop() = timer.shutdown()
}

// eine reelle Zahl im Format der Sprache des Rechners, ohne unnötige Nachkommastellen
fun format(value: Double): String = NumberFormat.getInstance().format(value)

// Anzeige mit der seit Beginn verstrichenen Zeit
fun display(message: String) =
    println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async28.Async28Kt
          measurement: 19.5 °C
          measurement: 20 °C
          measurement: 20.5 °C
          measurement: 21 °C
  961 ms : 1 - temperature reached: 21 °C, listeners: 0
          measurement: 21.5 °C
          measurement: 22 °C
          measurement: 22.5 °C
 1571 ms : 2 - result: null, listeners: 1
 1578 ms : 2 - after cancel(): listeners: 0
          measurement: 23 °C
          measurement: 23.5 °C
          measurement: 24 °C
 2181 ms : 3 - 30 °C not reached in 600 ms, listeners: 0

Erläuterungen:

  • Zeilen 75–93: 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 [(Double) -> Unit]. 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. Die Eigenschaft [nbListeners] dient dazu zu überprüfen, dass die Listener ordnungsgemäß entfernt wurden;
  • Zeilen 46–56: die Funktion, die Benachrichtigungen in ein [Deferred] umwandelt. Sie erstellt ein temporäres [CompletableDeferred<Double>], registriert einen Listener beim Thermometer und gibt sofort das [CompletableDeferred] zurück (behandelt als [Deferred<Double>]: Der Aufrufer kann es nicht selbst beenden), das noch nicht abgeschlossen ist;
  • Zeilen 49–50: Bei jeder Messung prüft der Listener den Schwellenwert. Ist er erreicht, beendet er das [CompletableDeferred] mit der Temperatur als Ergebnis. Nachfolgende Messungen würden weiterhin [complete] aufrufen, ohne Wirkung, bis der Listener entfernt wird;
  • Zeile 54: Unabhängig davon, wie [Deferred] endet (Schwellenwert erreicht, Fehlschlag, Abbruch), entfernt die von [invokeOnCompletion] registrierte Aktion den Listener: Dies ist das [whenComplete] im Java-Programm. Ohne sie bliebe ein Listener, dessen Schwellenwert nie erreicht wird, unbegrenzt registriert;
  • Zeilen 24–26: Für den Aufrufer ist das Warten auf eine Temperatur eine asynchrone Operation wie jede andere: Er wartet mit [await()] darauf. Sobald der Schwellenwert erreicht ist, wurde der Listener entfernt (Zeile 6 der Ergebnisse: 0 Listener);
  • Zeilen 28–34: ein wesentlicher Unterschied zum Java-Programm, in dem [orTimeout] das [CompletableFuture] selbst beendete. Hier bricht [withTimeoutOrNull] den Warte-Block ([await()]) ab, nicht das erwartete [Deferred]: Nach 600 ms wird das Warten aufgegeben ([null]), aber die Operation läuft weiter, und ihr Listener ist weiterhin registriert (Zeile 10 der Ergebnisse: 1 Listener). Ein [CompletableDeferred] ist das Kind keiner Coroutine: Die strukturierte Nebenläufigkeit gilt für es nicht, und es ist Sache seines Erstellers, es mit [cancel()] abzubrechen, wodurch der Listener entfernt wird (Zeile 11);
  • Zeilen 60–71: dasselbe Warten, geschrieben als Suspend-Funktion mit [suspendCancellableCoroutine]. Der Listener setzt die Coroutine mit der Temperatur fort ([resume]), nachdem er sich selbst entfernt hat. Da er auf sich selbst verweisen muss, wird er vor seiner Initialisierung mit [lateinit var] deklariert: Ein Lambda kann nicht auf die Variable verweisen, der es gerade zugewiesen wird. Der Test [continuation.isActive] verhindert, dass die Fortsetzung zweimal ausgeführt wird (was eine [IllegalStateException] auslösen würde). [invokeOnCancellation] registriert die Aktion, die auszuführen ist, wenn die Coroutine während des Wartens abgebrochen wird: das Entfernen des Listeners;
  • Zeilen 36–40: Diesmal bricht [withTimeout] die in [temperatureReached] suspendierte Coroutine ab: Die Aktion [invokeOnCancellation] entfernt den Listener, und es bleibt nichts weiter zu tun (Zeile 15: 0 Listener).

Wir bevorzugen daher die zweite Form: Eine Suspend-Funktion , die mit [suspendCancellableCoroutine] erstellt wurde, nimmt am Abbruch und an der strukturierten Nebenläufigkeit teil, während ein [CompletableDeferred] ein eigenständiges Objekt ist, das sein Ersteller in allen Fällen beenden muss. Das [CompletableDeferred] bleibt nützlich für einen Wert, der von mehreren Coroutinen erwartet wird (zum Beispiel ein Startsignal), oder für ein Ergebnis, das eine Coroutine einer anderen liefert. Eine Vorsichtsmaßnahme, dieselbe wie in Java: Der Listener wird vom Thread des Thermometers mitten in der Benachrichtigung seiner Listener ausgeführt; er muss kurz gehalten werden. Das ist hier der Fall: [complete] und [resume] delegieren die Fortsetzung der Coroutine einfach an ihren Dispatcher (den Hauptthread, den von [runBlocking]).

9.12. Begrenzte Parallelität

9.12.1. Semaphore und limitedParallelism

[awaitAll] und eine Coroutine 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. Wie virtuelle Threads werden Coroutinen nicht gepoolt (sie sind so günstig, dass pro Aufgabe eine gestartet wird): Begrenzt wird stattdessen der Zugriff auf die knappe Ressource. Kotlinx.coroutines stellt hierfür zwei Werkzeuge bereit:

  • ein Coroutine-Semaphor, die Klasse [Semaphore] aus dem Paket [kotlinx.coroutines.sync] (nicht zu verwechseln mit der aus [java.util.concurrent], die in Kapitel 8 vorgestellt wurde): Seine Berechtigungen stehen für die Anzahl der erlaubten gleichzeitigen Operationen; eine Coroutine, die auf eine Berechtigung wartet, wird suspendiert, ohne einen Thread zu blockieren;
  • eine begrenzte Sicht auf einen Dispatcher, [dispatcher.limitedParallelism(n)], vorgestellt im Programm [Async09.kt]: ein Dispatcher, der die Threads des ursprünglichen Dispatchers nutzt, aber nie mehr als [n] gleichzeitig.

Das Programm [Async29.kt] übernimmt das Java-Programm, das neun Seiten herunterlud – nicht mehr als drei gleichzeitig –, und vergleicht dann die beiden Werkzeuge:

// Verarbeitung einer Collection mit begrenzter Anzahl gleichzeitiger Operationen:
// der Semaphore von kotlinx.coroutines, dann limitedParallelism
package async29

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit
import java.util.concurrent.atomic.AtomicInteger
import kotlin.time.measureTime

val pages = (1..9).map { "page$it.html" }
val inProgress = AtomicInteger()
val maximum = AtomicInteger()
var start = System.nanoTime()

fun main() = runBlocking {
    // 1 - höchstens 3 Downloads gleichzeitig: ein Coroutinen-Semaphor mit 3 Berechtigungen
    start = System.nanoTime()
    val permits = Semaphore(3)
    coroutineScope {
        // eine Coroutine pro Seite: sie sind günstig, es können so viele gestartet werden, wie es Seiten gibt
        for (page in pages) {
            launch {
                // die Coroutine wartet auf eine Berechtigung (sie wird ausgesetzt, ohne einen Thread zu blockieren)
                permits.withPermit { download(page, trace = true) }
            }
        }
    }
    display("1 - the ${pages.size} pages are downloaded")

    // 2 - blockierende Downloads auf einer auf 3 Threads begrenzten Sicht des IO-Dispatchers
    val threeThreads = Dispatchers.IO.limitedParallelism(3)
    maximum.set(0)
    val duration2 = measureTime {
        coroutineScope {
            for (page in pages) launch(threeThreads) { downloadBlocking(page) }
        }
    }
    println("2 - limitedParallelism(3), blocking: ${duration2.inWholeMilliseconds} ms, " +
            "at most ${maximum.get()} in progress")

    // 3 - dieselbe Sicht begrenzt die Threads, nicht die ausgesetzten Coroutinen: hier keine Begrenzung
    maximum.set(0)
    val duration3 = measureTime {
        coroutineScope {
            for (page in pages) launch(threeThreads) { download(page) }
        }
    }
    println("3 - limitedParallelism(3), suspended: ${duration3.inWholeMilliseconds} ms, " +
            "at most ${maximum.get()} in progress")
}

// der simulierte Download einer Seite durch eine suspendierende Funktion
suspend fun download(page: String, trace: Boolean = false) {
    // von den gleichzeitigen Operationen gemeinsam genutzter Zähler: er wird atomar geändert
    val n = inProgress.incrementAndGet()
    maximum.accumulateAndGet(n, ::maxOf)
    if (trace) display("start of $page ($n in progress)")
    delay(1000)
    inProgress.decrementAndGet()
    if (trace) display("end of $page")
}

// derselbe Download, durch eine blockierende Funktion
fun downloadBlocking(page: String) {
    val n = inProgress.incrementAndGet()
    maximum.accumulateAndGet(n, ::maxOf)
    Thread.sleep(1000)
    inProgress.decrementAndGet()
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) =
    println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async29.Async29Kt
   39 ms : start of page1.html (1 in progress)
   76 ms : start of page2.html (2 in progress)
   76 ms : start of page3.html (3 in progress)
 1118 ms : end of page1.html
 1122 ms : end of page2.html
 1122 ms : end of page3.html
 1122 ms : start of page4.html (1 in progress)
 1122 ms : start of page5.html (2 in progress)
 1122 ms : start of page6.html (3 in progress)
 2125 ms : end of page4.html
 2126 ms : end of page5.html
 2127 ms : end of page6.html
 2127 ms : start of page7.html (1 in progress)
 2127 ms : start of page8.html (2 in progress)
 2128 ms : start of page9.html (3 in progress)
 3135 ms : end of page7.html
 3142 ms : end of page8.html
 3143 ms : end of page9.html
 3151 ms : 1 - the 9 pages are downloaded
2 - limitedParallelism(3), blocking: 3025 ms, at most 3 in progress
3 - limitedParallelism(3), suspended: 1006 ms, at most 9 in progress

Erläuterungen:

  • Zeile 23: ein Coroutine-Semaphor mit 3 Berechtigungen;
  • Zeilen 24–33: eine Coroutine pro Seite. Der Block [coroutineScope] wartet auf das Ende aller neun Coroutinen, ähnlich der Methode [close()] des Executors im Java-Programm;
  • Zeile 29: Jede Coroutine wartet auf eine Berechtigung, lädt ihre Seite herunter und gibt die Berechtigung dann zurück. Die Funktion [withPermit] erledigt all das: Sie nimmt eine Berechtigung ([acquire()], eine Suspend-Funktion), führt den Block aus und gibt die Berechtigung ([release()]) in einem [finally] zurück, sodass sie auch dann zurückgegeben wird, wenn der Block fehlschlägt oder die Coroutine abgebrochen wird. Das Java-Programm musste das [try / finally] selbst schreiben und die [InterruptedException] von [acquire] behandeln;
  • Zeilen 58–65: der simulierte Download einer Seite, eine Suspend-Funktion, die eine Sekunde wartet. Der Zähler [inProgress], den die Coroutinen gemeinsam nutzen, ist ein [AtomicInteger]: Die von [runBlocking] gestarteten Coroutinen laufen hier auf einem einzigen Thread, die aus den Teilen 2 und 3 dagegen auf mehreren Threads. Der Zähler [maximum] hält die höchste Anzahl gleichzeitiger Downloads fest: [accumulateAndGet(n, ::maxOf)] ersetzt ihn atomar durch den größeren Wert aus seinem eigenen und dem von [n] (die Funktion [maxOf]der Standardbibliothek, per Referenz übergeben);
  • Die Ergebnisse aus Teil 1 zeigen drei Wellen von je drei Seiten: Sobald eine Seite fertig ist, beginnt eine weitere, und die Anzahl der aktiven Downloads überschreitet nie 3. Der gesamte Vorgang dauert 3 statt 9 Sekunden. Diese neun Coroutinen wurden von einem einzigen Thread ausgeführt, dem von [runBlocking];
  • Zeilen 35–43: [Dispatchers.IO.limitedParallelism(3)] ist eine auf 3 Threads begrenzte Sicht auf den [IO]-Dispatcher. Die neun Coroutinen werden auf dieser Sicht gestartet und führen einen blockierenden Download aus ([Thread.sleep]): Nur drei können gleichzeitig laufen; die anderen warten, bis ein Thread frei wird. Der gesamte Vorgang dauert 3 Sekunden, mit höchstens 3 laufenden Downloads (Zeile 21 der Ergebnisse). Dies ist das richtige Werkzeug, um eine blockierende Aufgabe (eine JDBC-Bibliothek, Dateien) oder eine Berechnung zu begrenzen: Eine von [Dispatchers.IO] mit [limitedParallelism] erzeugte Sicht kann sogar die Grenze von 64 Threads von [Dispatchers.IO] überschreiten, sodass jeder blockierenden Ressource ein eigenes Thread-Kontingent zugewiesen werden kann (zum Beispiel so viele, wie ein Datenbank-Connection-Pool Verbindungen hat);
  • Zeilen 46–53: dieselbe Sicht, wobei der Download pausiert ([delay]). Diesmal laufen alle neun Downloads gleichzeitig, und der gesamte Vorgang dauert eine Sekunde (Zeile 22). [limitedParallelism] begrenzt die Anzahl der Coroutinen, die gleichzeitig laufen, das heißt die Anzahl der belegten Threads; eine suspendierte Coroutine belegt keinen Thread und wird nicht gezählt. Um die Anzahl der laufenden Operationen (Verbindungen, Abfragen) zu begrenzen, müssen Sie daher den Semaphor verwenden.

Kernaussage: limitedParallelism begrenzt Threads; der Semaphor begrenzt Operationen.

9.12.2. Erzeuger/Verbraucher: Worker lesen einen Channel

Das vorige Kapitel führte das Modell Erzeuger/Verbraucher mit einer [BlockingQueue] ein, und der Java-Kurs implementierte es mit virtuellen Threads. Mit Coroutinen ist das Werkzeug der Channel: [send] ersetzt [put], die Schleife [for] über den Channel ersetzt die aufeinanderfolgenden [take]-Aufrufe, und [trySend] ersetzt [offer] (ein nicht blockierender Versuch). Mehrere Coroutinen, die denselben Channel lesen, teilen sich seine Werte: Dies ist eine weitere Möglichkeit, die Parallelität zu begrenzen, indem man eine feste Anzahl von „Workern“ startet, die Aufgaben nacheinander abarbeiten. Im Programm [Async30.kt] werden Bestellungen – alle 50 ms erzeugt – von zwei Verbrauchern verarbeitet, die jeweils 400 ms für eine Bestellung benötigen:

// Producer / Consumer: "Worker"-Coroutinen, die sich die Aufträge eines Channels teilen
package async30

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.channels.SendChannel
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

val start = System.nanoTime()

fun main() = runBlocking {
    // ein begrenzter Channel: er enthält höchstens 2 auf Verarbeitung wartende Aufträge
    val orders = Channel<Int>(capacity = 2)
    coroutineScope {
        // der Producer und zwei Consumer arbeiten gleichzeitig
        launch { produceOrders(orders, 8) }
        launchWorkers(orders, "C1", "C2")
    }
    display("all the orders have been processed")
}

// der Producer: ein Auftrag alle 50 ms
suspend fun produceOrders(orders: SendChannel<Int>, nbOrders: Int) {
    for (i in 1..nbOrders) {
        delay(50)
        // trySend legt den Auftrag sofort ab, wenn im Channel Platz ist
        if (orders.trySend(i).isSuccess) {
            display("P  : order $i put")
        } else {
            // Channel voll: send setzt den Producer aus, bis ein Platz frei wird
            display("P  : channel full, order $i waits")
            orders.send(i)
            display("P  : order $i put")
        }
    }
    // es wird nichts mehr produziert: der Channel wird geschlossen
    orders.close()
    display("P  : end of production")
}

// startet einen Worker pro Name: jeder empfängt die Aufträge des Channels, bis er geschlossen wird
fun CoroutineScope.launchWorkers(orders: ReceiveChannel<Int>, vararg names: String) {
    for (name in names) {
        launch {
            // die Verarbeitung eines Auftrags dauert 400 ms
            for (order in orders) {
                display("$name : processing order $order")
                delay(400)
            }
            display("$name : no more orders")
        }
    }
}

// Anzeige mit der seit Beginn verstrichenen Zeit
fun display(message: String) =
    println("%5d ms : %s".format((System.nanoTime() - start) / 1_000_000, message))

Ergebnisse:

> gradlew -q run -Pmain=async30.Async30Kt
  195 ms : P  : order 1 put
  225 ms : C1 : processing order 1
  271 ms : P  : order 2 put
  271 ms : C2 : processing order 2
  322 ms : P  : order 3 put
  373 ms : P  : order 4 put
  423 ms : P  : channel full, order 5 waits
  625 ms : C1 : processing order 3
  626 ms : P  : order 5 put
  672 ms : C2 : processing order 4
  676 ms : P  : order 6 put
  727 ms : P  : channel full, order 7 waits
 1026 ms : C1 : processing order 5
 1026 ms : P  : order 7 put
 1073 ms : C2 : processing order 6
 1077 ms : P  : order 8 put
 1079 ms : P  : end of production
 1427 ms : C1 : processing order 7
 1473 ms : C2 : processing order 8
 1833 ms : C1 : no more orders
 1874 ms : C2 : no more orders
 1875 ms : all the orders have been processed

Erläuterungen:

  • Zeile 17: ein Channel mit der Kapazität 2: Er enthält höchstens 2 wartende Bestellungen;
  • Zeilen 18–21: Der Erzeuger und die beiden Verbraucher sind drei Kind-Coroutinen des Blocks [coroutineScope], der auf das Ende aller drei wartet;
  • Zeilen 27–42: Der Erzeuger erhält den Channel als [SendChannel<Int>], den „Sende“-Teil des Channels: Er kann nur senden. Er versucht, jede Bestellung mit [trySend] abzulegen, das nie suspendiert und ein [ChannelResult] zurückgibt, dessen Eigenschaft [isSuccess] anzeigt, ob der Wert abgelegt wurde. Ist der Channel voll, meldet er dies und wartet mit [send] auf Platz: Der Erzeuger wird an das Tempo der Verbraucher angepasst (Zeilen 8–10 der Ergebnisse). Das ist der Vorteil eines begrenzten Channels: Ein zu schneller Erzeuger kann den Speicher nicht füllen;
  • Zeile 41: Die Erzeugung ist abgeschlossen; der Erzeuger schließt den Channel. Das Java-Programm musste einen besonderen Wert – die Endemarkierung – ablegen, den jeder Verbraucher erkannte und für den nächsten wieder in die Warteschlange stellte; ein Channel hingegen weiß, wann er geschlossen ist. Das Schließen des Channels erfordert keinen freien Platz im Channel: Das Ende der Erzeugung wird signalisiert, sobald die letzte Bestellung abgelegt ist (Zeile 18), während in Java das Ablegen der Endemarkierung auf einen freien Platz warten musste;
  • Zeilen 46–54: Die Verbraucher werden von einer Erweiterungsfunktion von [CoroutineScope] (Programm [Async25.kt]) gestartet, deren Parameter [vararg names] (Kapitel 3) beliebig viele Namen akzeptiert. Jeder Worker durchläuft den Channel mit einer [for]-Schleife, die endet, wenn der Channel geschlossen und leer ist. Eine Bestellung wird nur an einen Worker ausgeliefert: Die Bestellungen werden je nach Verfügbarkeit auf C1 und C2 verteilt;
  • Zwei Zeilen, die nahezu gleichzeitig ausgegeben werden, können von einem Lauf zum nächsten in unterschiedlicher Reihenfolge erscheinen.

Um eine im Voraus bekannte Liste mit [n] Workern zu verarbeiten, senden wir die Elemente in einen Channel, schließen ihn und starten [n] Coroutinen, die aus ihm lesen: Anders als bei einem Semaphor, der eine Coroutine pro Element startet, werden hier nur [n] Coroutinen gestartet, was bei Millionen von Elementen einen Unterschied macht.

9.13. Zeit

Wenn es in Coroutinen um Zeit geht, ist die erste Funktion, die man in Betracht ziehen sollte, [delay]: ein Warten, das keinen Thread blockiert, abbrechbar ist und entweder eine Anzahl von Millisekunden oder eine Dauer akzeptiert ([Duration]: [delay(500.milliseconds)]). Die Funktionen [withTimeout] und [withTimeoutOrNull] (Programm [Async19.kt]) begrenzen die Dauer eines Blocks. Mit diesen beiden Werkzeugen ist das Schreiben eines Timers einfach: eine Coroutine, die in einer Schleife zwischen zwei Aktionen wartet und durch ihren Abbruch gestoppt wird. Der Java-Kurs verwendete hierfür einen [ScheduledExecutorService]; das Programm [Async31.kt] implementiert beide Arten periodischer Timer mit Coroutinen und verwendet dann die Klasse [Reception] aus dem Java-Programm wieder, die von der Uhrzeit abhängt:

// Zeit: mit delay geschriebene Timer und eine injizierte Uhr (Clock)
package async31

import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import java.time.Clock
import java.time.Instant
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.TimeSource

fun main() = runBlocking {
    // 1 - eine Aktion alle 500 ms: eine feste Verzögerung zwischen dem Ende einer Aktion und dem Start der nächsten
    var start = TimeSource.Monotonic.markNow()
    var nbTicks = 0
    val ticks = launch {
        while (true) {
            delay(500)
            nbTicks++
            println("%6d ms : tick no. %d".format(start.elapsedNow().inWholeMilliseconds, nbTicks))
            // die Aktion selbst dauert 100 ms
            delay(100)
        }
    }
    // eine einzelne Aktion, in 2,2 Sekunden, die die Ticks stoppt
    delay(2200)
    ticks.cancelAndJoin()
    println("%6d ms : 1 - timer stopped after %d ticks"
        .format(start.elapsedNow().inWholeMilliseconds, nbTicks))

    // 2 - in festen Intervallen: jeder Tick richtet sich nach dem geplanten Zeitpunkt, trotz der Dauer der Aktion
    start = TimeSource.Monotonic.markNow()
    nbTicks = 0
    val ticks2 = launch {
        var next = start + 500.milliseconds
        while (true) {
            // wir warten die bis zum geplanten Zeitpunkt verbleibende Zeit (nichts, wenn er schon verstrichen ist)
            delay(-next.elapsedNow())
            nbTicks++
            println("%6d ms : tick no. %d".format(start.elapsedNow().inWholeMilliseconds, nbTicks))
            delay(100)
            next += 500.milliseconds
        }
    }
    delay(2200)
    ticks2.cancelAndJoin()
    println("%6d ms : 2 - timer stopped after %d ticks"
        .format(start.elapsedNow().inWholeMilliseconds, nbTicks))

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

// eine von der aktuellen Zeit abhängige Klasse
class Reception(private val clock: Clock) {
    fun greet(name: String): String {
        val now = LocalDateTime.now(clock)
        val greeting = if (now.hour < 18) "Hello" else "Good evening"
        val date = now.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm"))
        return "[$date] $greeting $name"
    }
}

Ergebnisse:

> gradlew -q run -Pmain=async31.Async31Kt
   511 ms : tick no. 1
  1145 ms : tick no. 2
  1746 ms : tick no. 3
  2229 ms : 1 - timer stopped after 3 ticks
   501 ms : tick no. 1
  1000 ms : tick no. 2
  1500 ms : tick no. 3
  2001 ms : tick no. 4
  2201 ms : 2 - timer stopped after 4 ticks
[03/10/2026 09:30] Hello Pierre
[03/10/2026 19:45] Good evening Pierre
[04/10/2026 13:03] Hello Pierre (system clock)

Erläuterungen:

  • Zeile 18: Um eine Dauer zu messen, verwenden wir hier den monotonen Timer der Kotlin-Standardbibliothek: [TimeSource.Monotonic.markNow()] gibt einen Zeitstempel für den aktuellen Moment zurück, und [start.elapsedNow()] gibt die Dauer ([Duration]) zurück, die seitdem verstrichen ist. Das entspricht [System.nanoTime()], das wir bisher verwendet haben, aber mit typisierten Dauern;
  • Zeilen 20–31: eine Aktion alle 500 ms, ausgeführt von einer Coroutine, die endlos in einer Schleife läuft ([while (true)]). Die Schleife birgt kein Risiko: Jedes [delay] ist ein Abbruchpunkt. Nach 2,2 Sekunden bricht die Haupt-Coroutine sie ab und wartet auf ihr Ende ([cancelAndJoin()]). Die Variable [nbTicks] ist eine einfache lokale Variable ([var]), die vom Lambda in [launch] geändert wird: Kotlin erlaubt einer Closure, eine erfasste Variable zu ändern (Kapitel 7), während Java einen [AtomicInteger] benötigte; das ist hier sicher, weil alle Coroutinen auf dem einzigen Thread von [runBlocking] laufen;
  • Dieser erste Timer wartet 500 ms nach jeder Aktion, die selbst 100 ms dauert: Der Timer löst alle 600 ms aus (Zeilen 2–4 der Ergebnisse; das erste Intervall ist etwas länger, während die Klassen geladen werden). Das ist das Verhalten der Methode [scheduleWithFixedDelay] eines [ScheduledExecutorService]: eine feste Verzögerung zwischen dem Ende einer Ausführung und dem Beginn der nächsten;
  • Zeilen 38–46: Der zweite Timer ist auf feste Intervalle eingestellt: 500, 1.000, 1.500, 2.000 ms (Zeilen 6–9), unabhängig von der Dauer der Aktion. Die Variable [next] ist der Zeitstempel des nächsten Auslösens ([start + 500.milliseconds]: Ein Zeitstempel plus eine Dauer ergibt einen Zeitstempel). [next.elapsedNow()] ist negativ, solange dieser Zeitpunkt in der Zukunft liegt: [delay(-next.elapsedNow())] wartet daher die verbleibende Zeit (eine negative oder null betragende Verzögerung führt zu keinem Warten). Das ist das Verhalten von [scheduleAtFixedRate]. Kotlinx.coroutines hat keine integrierte, stabile Timer-Funktion (die Funktion [ticker] ist als veraltet markiert): Die Schleife ist der empfohlene Ansatz;
  • Zeilen 63–68: Die Klasse [Reception] sagt je nach Uhrzeit „Guten Tag“ oder „Guten Abend“. Sie erhält ihre Uhr, eine [java.time.Clock], in ihrem Konstruktor, statt [LocalDateTime.now()] aufzurufen: Dies ist eine injizierte Abhängigkeit, so wie die [dao]-Schicht in Kapitel 6 in die [business]-Schicht injiziert wird. [now.hour] ist der Aufruf der Java-Methode [getHour()], behandelt als Eigenschaft;
  • Zeilen 55–59: [Clock.fixed(instant, zone)] liefert eine angehaltene Uhr, die immer dieselbe Zeit zurückgibt: So können wir das Verhalten von [Reception] am Morgen und am Abend überprüfen, ohne bis zum Abend warten zu müssen. Die letzte Zeile verwendet die Systemuhr: Das Ergebnis hängt daher von der Ausführungszeit ab.

Zur Erinnerung: Der [ScheduledExecutorService] aus dem Java-Kurs kann in Kotlin weiterhin verwendet werden (das Thermometer im Programm [Async28.kt] verwendet einen), aber seine Aufgaben sind [Runnable]s , die von eigenen Threads außerhalb jeder Coroutine ausgeführt werden. In einem Coroutine-basierten Programm ist es vorzuziehen, eine Coroutine und [delay] zu verwenden, die zusammen mit ihrem Scope enden.

Die Zeitfunktionen der Coroutinen haben einen weiteren Vorteil, der für Tests besonders bedeutsam ist: Das Modul [kotlinx-coroutines-test] stellt eine Funktion [runTest] bereit, die Coroutinen mit virtueller Zeit ausführt: Die Funktionen [delay] warten nicht wirklich; die virtuelle Uhr springt sofort weiter, und ein Test, der eine Wartezeit von einer Minute simuliert, dauert nur wenige Millisekunden.

9.14. Coroutinen und virtuelle Threads

Der Java-Kurs schloss dieses Kapitel mit einem Überblick über die strukturierte Nebenläufigkeit ab, die eine Gruppe von Teilaufgaben als Block behandelt: Sie werden innerhalb eines Scopes gestartet, der Scope wartet auf ihr Ende, und wenn eine fehlschlägt, werden die anderen abgebrochen. In Kotlin ist dies nicht nur ein Überblick, sondern das eigentliche Fundament der Coroutinen, das zu Beginn dieses Kapitels eingeführt wurde ([coroutineScope], [supervisorScope], Programm [Async11.kt]) und seither in allen Beispielen verwendet wurde. Ein Vergleich der beiden Sprachen ist interessant, da sich Java in dieselbe Richtung entwickelt.

9.14.1. StructuredTaskScope (Java) und coroutineScope (Kotlin)

Die Java-Klasse [StructuredTaskScope] implementiert strukturierte Nebenläufigkeit mit virtuellen Threads. Sie ist seit Java 21 verfügbar, befindet sich in Java 25 aber noch 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. Hier der im Java-Kurs vorgestellte Code (Datei [preview/StructuredConcurrency.txt] im Ordner [09-async] des Java-Kurses):

// 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 (Ausführung mit JDK 25):

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

[StructuredTaskScope.open()] öffnet einen Scope, der in [try] mit einer Ressource deklariert wird; [fork] startet eine Teilaufgabe in einem neuen virtuellen Thread; [join()] wartet auf das Ende aller Teilaufgaben und beendet, falls eine fehlschlägt, die anderen und wirft eine Ausnahme; ein [Joiner] wählt eine andere Strategie, etwa „Die erste erfolgreiche Teilaufgabe liefert das Ergebnis“. Das Programm [Async32.kt] macht dasselbe mit Coroutinen und zeigt anschließend, dass Coroutinen auch blockierenden Code behandeln können, der von virtuellen Threads ausgeführt wird:

// die strukturierte Nebenläufigkeit von Kotlin im Vergleich zu StructuredTaskScope (Java):
// dieselben Teilaufgaben als Coroutinen, dann blockierender Code auf virtuellen Threads
package async32

import kotlinx.coroutines.async
import kotlinx.coroutines.asCoroutineDispatcher
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.runInterruptible
import kotlinx.coroutines.selects.select
import java.util.concurrent.Executors
import kotlin.time.TimeSource

var start = TimeSource.Monotonic.markNow()

fun main() = runBlocking<Unit> {
    start = TimeSource.Monotonic.markNow()
    // 1 - zwei Teilaufgaben, die beide erfolgreich sein müssen
    val (angers, brest) = coroutineScope {
        val angers = async { readTemperature("Angers", 1000) }
        val brest = async { readTemperature("Brest", 500) }
        angers.await() to brest.await()
    }
    display("1 - Angers: $angers, Brest: $brest")

    // 2 - die erste Antwort genügt: die anderen Teilaufgaben werden abgebrochen
    val first = coroutineScope {
        val mirrors = listOf(
            async { readTemperature("mirror-paris", 800) },
            async { readTemperature("mirror-lyon", 300) })
        select { mirrors.forEach { mirror -> mirror.onAwait { it } } }
            .also { mirrors.forEach { it.cancel() } }
    }
    display("2 - first answer: $first")

    // 3 - blockierender Code auf virtuellen Threads: der Fehlschlag einer Teilaufgabe unterbricht die andere
    Executors.newVirtualThreadPerTaskExecutor().asCoroutineDispatcher().use { virtuals ->
        try {
            coroutineScope {
                async(virtuals) { runInterruptible { readTemperatureBlocking("Colmar", 1000) } }
                async(virtuals) { runInterruptible { readTemperatureBlocking("", 200) } }
            }
        } catch (e: IllegalArgumentException) {
            display("3 - failure: ${e.message}")
        }
    }
}

// ein Lesevorgang, der die Coroutine aussetzt
suspend fun readTemperature(city: String, duration: Long): Int {
    delay(duration)
    return 10 + city.length
}

// ein blockierender Lesevorgang, der seine Unterbrechung anzeigt
fun readTemperatureBlocking(city: String, duration: Long): Int {
    try {
        Thread.sleep(duration)
    } catch (e: InterruptedException) {
        display("    $city: read interrupted, by ${Thread.currentThread()}")
        throw e
    }
    require(city.isNotEmpty()) { "unknown city" }
    return 10 + city.length
}

// Anzeige mit der seit [start] verstrichenen Zeit
fun display(message: String) = println("%5d ms : %s".format(start.elapsedNow().inWholeMilliseconds, message))

Ergebnisse:

1
2
3
4
5
> gradlew -q run -Pmain=async32.Async32Kt
 1023 ms : 1 - Angers: 16, Brest: 15
 1403 ms : 2 - first answer: 21
 1625 ms :     Colmar: read interrupted, by VirtualThread[#22]/runnable@ForkJoinPool-1-worker-2
 1628 ms : 3 - failure: unknown city

Kommentare:

  • Zeilen 19–23: Der Block [coroutineScope] fungiert als Java-Scope: Die beiden von [async] gestarteten Teilaufgaben sind seine Kinder; er endet erst, wenn sie beendet sind, und wenn eine fehlschlägt, wird die andere abgebrochen und die Ausnahme erneut geworfen. Der Block liefert ein Paar ([to], Kapitel 3), das mit einer Destrukturierungszuweisung entpackt wird. Die Dauer des Ganzen entspricht der der längsten Teilaufgabe, einer Sekunde (Zeile 2 der Ergebnisse). Es gibt weder ein [try] mit Ressource noch ein [join()] oder ein [Subtask.get()]: Der Scope ist ein Codeblock, und das Ergebnis einer Teilaufgabe ist das Ergebnis von [await()];
  • Zeilen 27–33: Die Strategie „Die erste Antwort genügt“ wird mit [select] (Programm [Async13.kt]) umgesetzt, das auf die erste abgeschlossene Teilaufgabe wartet und dann alle anderen abbricht (das Abbrechen einer bereits abgeschlossenen Coroutine hat keine Wirkung). Ohne diese Abbrüche würde der Block [coroutineScope] auf das Ende des Pariser Spiegelservers warten. Die Antwort trifft nach 300 ms ein (Zeile 3);
  • Zeilen 37–45: Dieses Mal führen die Teilaufgaben blockierenden Code ([Thread.sleep]) auf einem Dispatcher aus, dessen Threads virtuelle Threads sind (Programm [Async09.kt]). Die Funktion [runInterruptible] (Programm [Async19.kt]) wandelt den Abbruch der Coroutine in eine Unterbrechung des Threads um, der den blockierenden Code ausführt. Die zweite Teilaufgabe schlägt nach 200 ms fehl ([require] wirft eine [IllegalArgumentException]); der Scope bricht daraufhin die erste ab, und [runInterruptible] unterbricht deren virtuellen Thread, dessen [Thread.sleep] eine [InterruptedException] wirft (Zeile 4 der Ausgabe: Der Thread, der die Meldung anzeigt, ist ein [VirtualThread], der auf einem Carrier-Thread des [ForkJoinPool] eingehängt ist). Die ursprüngliche Ausnahme wird anschließend von [coroutineScope] aus geworfen (Zeile 5). Genau so verhält sich [StructuredTaskScope]: Die strukturierte Nebenläufigkeit von Kotlin gilt auch für blockierenden Code;
  • der Dispatcher für virtuelle Threads wird am Ende des Blocks durch [use] geschlossen, wodurch sein Executor beendet wird.

9.14.2. Wann sollte man das eine dem anderen vorziehen?

Virtuelle Threads und Coroutinen lösen dasselbe Problem: Code, der viel wartet (auf I/O), sequentiell und lesbar zu schreiben, ohne beim Warten einen System-Thread zu blockieren. Sie tun dies auf zwei gegensätzliche Arten:

 
Virtuelle Threads (Java 21)
Coroutinen (Kotlin)
Wo der Mechanismus liegt
in der JVM: Der Stack des virtuellen Threads wird während eines Wartevorgangs in den Heap kopiert
im Compiler und in einer Bibliothek: Eine [suspend]-Funktion wird in eine Zustandsmaschine umgewandelt
Was suspendiert
alle blockierenden Operationen im JDK ([Thread.sleep], Sockets, [BlockingQueue], Sperren)
nur die Suspend-Funktionen ([delay], [await], [send] …); blockierender Code muss vom Dispatcher [IO] übernommen werden
Bestehender Code
unverändert: Jede Bibliothek mit blockierenden Aufrufen (JDBC, HTTP-Client) profitiert davon ohne Änderung
Es sind [suspend]-Versionen der API erforderlich oder Adapter ([await()], [withContext(Dispatchers.IO)])
Kennzeichnung im Code
Keine: Eine blockierende Methode sieht aus wie jede andere
Das Schlüsselwort [suspend] kennzeichnet Funktionen, die warten können (man spricht von „gefärbten Funktionen“)
Strukturierte Nebenläufigkeit
[StructuredTaskScope], in Java 25 noch in der Preview
[coroutineScope], [supervisorScope], [Job]: seit 2018 stabil, Kern des Modells
Abbruch
Unterbrechung des Threads ([Thread.interrupt]), auf die jede Bibliothek auf ihre eigene Weise reagiert
kooperativer Abbruch, der durch den Coroutinen-Baum propagiert wird, mit [CancellationException], [withTimeout], [NonCancellable]
Wertströme, Channels
blockierende [Stream], [BlockingQueue], [java.util.concurrent.Flow]
[Flow], [Channel], [SharedFlow], [StateFlow] mit ihren Operatoren
Thread-Auswahl
keine: Ein virtueller Thread läuft auf einem beliebigen Carrier
Dispatcher ([Main], [Default], [IO], [limitedParallelism])
Plattformen
JVM (ab 21)
JVM, Android (alle Versionen), JavaScript, Native (Kotlin Multiplatform)
Kosten einer wartenden Aufgabe
einige hundert Byte bis einige KB (der kopierte Stack)
einige zehn bis einige hundert Byte (das Continuation-Objekt)

Es geht nicht darum, sich für das eine oder das andere zu entscheiden: Beide lassen sich kombinieren, wie in Teil 3 des Programms [Async32.kt] gezeigt wird. Einige Orientierungspunkte:

  • Für ein Kotlin-Programm, das asynchrone Operationen orchestriert (Starten, Warten, Kombinieren, Begrenzen, Abbrechen und Verteilen von Werten), sind Coroutinen die natürliche Wahl: Sie bieten strukturierte Nebenläufigkeit, Abbruch, Datenströme und Dispatcher – Funktionen, die virtuelle Threads allein nicht (oder noch nicht) bieten;
  • Für blockierenden Code, der sich nicht umschreiben lässt (ein JDBC-Treiber, eine Java-Bibliothek mit blockierender I/O), verhindern virtuelle Threads die Erschöpfung der 64 Threads des [IO]-Dispatchers: Sie werden als Dispatcher eingesetzt ([Executors.newVirtualThreadPerTaskExecutor().asCoroutineDispatcher()]) oder direkt in einem Server, der jede Anfrage in einem virtuellen Thread verarbeitet (Spring Boot kann das);
  • Auf Android oder für Kotlin-Multiplatform-Code stehen ausschließlich Coroutinen zur Verfügung;
  • Java-Code, der Kotlin-Code aufruft, kann keine Suspend-Funktion direkt aufrufen: Stattdessen erhält er eine gewöhnliche Funktion, die ein [CompletableFuture] zurückgibt (mit der Funktion [future { … }] aus dem Programm [Async04.kt]), oder eine blockierende Funktion (mit [runBlocking]), die Java in einem virtuellen Thread aufrufen wird.

9.15. Anwendung: Steuerberechnung mit Coroutinen

Das Programm [Async33.kt] vereint mehrere Werkzeuge dieses Kapitels in der Steuerberechnung, die im roten Faden behandelt wird. Wie das Java-Programm ist es eigenständig (es verwendet nicht die Schichten aus Version 5 von Kapitel 6): Es liest die Steuerstufen aus der Datei [TaxData.txt], die bereits verwendet wurde, und liest eine Liste von Steuerzahlern aus der Datei [taxpayers.txt], die sich ebenfalls im Projektstamm befindet:

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 für jeden Steuerzahler und schreibt die Ergebnisse in die Datei [results.txt]. Die beiden Lesevorgänge werden gleichzeitig von zwei Coroutinen ausgeführt, und der gesamte Ablauf ist auf 10 Sekunden begrenzt. Anschließend berechnet das Programm die Steuern für eine Million fiktive Steuerzahler, zuerst sequentiell und dann parallel:

// Anwendung: die Steuerberechnung mit Coroutinen
// - die Stufen werden aus [TaxData.txt] (oder der als Argument übergebenen Datei) gelesen, die Steuerpflichtigen
//   aus [taxpayers.txt]: die beiden Lesevorgänge laufen gleichzeitig, auf dem IO-Dispatcher
// - die Ergebnisse werden in [results.txt] geschrieben
// - dann wird die Steuer einer großen Anzahl von Steuerpflichtigen parallel auf dem Default-Dispatcher berechnet
package async33

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.TimeoutCancellationException
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeout
import java.io.IOException
import java.math.BigDecimal
import java.math.MathContext
import java.nio.file.Path
import kotlin.io.path.bufferedWriter
import kotlin.io.path.readLines
import kotlin.io.path.readText
import kotlin.io.path.useLines
import kotlin.random.Random
import kotlin.time.Duration.Companion.seconds
import kotlin.time.measureTimedValue

// eine korrekte Zeile eines Steuerpflichtigen: verheiratet (y/n), Anzahl der Kinder, Jahresgehalt
val TAXPAYER = Regex("""([yn])\s+(\d+)\s+(\d+)""")

fun main(args: Array<String>) = runBlocking<Unit> {
    val results = Path.of("results.txt")
    val brackets = Path.of(args.getOrElse(0) { "TaxData.txt" })
    try {
        // 1 - die gesamte Verarbeitung ist auf 10 Sekunden begrenzt
        val nbResults = withTimeout(10.seconds) {
            process(brackets, Path.of("taxpayers.txt"), results)
        }
        println("$nbResults lines written to [$results]:")
        print(withContext(Dispatchers.IO) { results.readText() })
    } catch (e: TimeoutCancellationException) {
        println("processing abandoned: timeout exceeded")
        return@runBlocking
    } catch (e: IOException) {
        // der Fehler eines Lesevorgangs kommt hier unverändert an
        println("error: ${e::class.simpleName} : ${e.message}")
        return@runBlocking
    }

    // 2 - eine reine Berechnung für eine große Anzahl von Steuerpflichtigen: nacheinander, dann parallel
    val scale = withContext(Dispatchers.IO) { loadBrackets(brackets) }
    val random = Random(2026)
    val crowd = List(1_000_000) {
        Taxpayer(random.nextBoolean(), random.nextInt(0, 5), random.nextInt(10_000, 150_000))
    }
    val (total1, duration1) = measureTimedValue { crowd.sumOf { calculateTax(scale, it).toLong() } }
    println("2 - in sequence: total = %,d €, in %d ms".format(total1, duration1.inWholeMilliseconds))
    val (total2, duration2) = measureTimedValue {
        withContext(Dispatchers.Default) {
            // ein Stapel von Steuerpflichtigen pro Coroutine, so viele Stapel wie Prozessoren
            val size = crowd.size / Runtime.getRuntime().availableProcessors() + 1
            crowd.chunked(size)
                .map { batch -> async { batch.sumOf { calculateTax(scale, it).toLong() } } }
                .awaitAll()
                .sum()
        }
    }
    println("2 - in parallel: total = %,d €, in %d ms".format(total2, duration2.inWholeMilliseconds))
}

// die beiden Dateien werden gleichzeitig gelesen; die Berechnung wartet auf beide Lesevorgänge und schreibt dann die Ergebnisse
suspend fun process(bracketsFile: Path, taxpayersFile: Path, output: Path): Int = coroutineScope {
    val brackets = async(Dispatchers.IO) { loadBrackets(bracketsFile) }
    val taxpayers = async(Dispatchers.IO) { taxpayersFile.readLines() }
    calculateTaxes(brackets.await(), taxpayers.await(), output)
}

// liest die Steuerstufen (limit:coeffR:coeffN, Dezimalpunkt) und ignoriert leere Zeilen
fun loadBrackets(file: Path): List<TaxBracket> =
    file.useLines { lines -> lines.filter { it.isNotBlank() }.map(TaxBracket::parse).toList() }

// berechnet die Steuer jedes Steuerpflichtigen und schreibt die Ergebnisse (E/A: auf dem IO-Dispatcher)
suspend fun calculateTaxes(brackets: List<TaxBracket>, taxpayers: List<String>, output: Path): Int =
    withContext(Dispatchers.IO) {
        output.bufferedWriter().use { writer ->
            for (line in taxpayers) {
                val result = TAXPAYER.matchEntire(line.trim())?.destructured
                    ?.let { (married, children, salary) ->
                        val taxpayer = Taxpayer(married == "y", children.toInt(), salary.toInt())
                        "tax = ${calculateTax(brackets, taxpayer)} €"
                    }
                    ?: "incorrect line"
                writer.write("%-12s : %s".format(line, result))
                writer.newLine()
            }
        }
        taxpayers.size
    }

// die Steuerberechnung (Steuertarif 2004 auf Einkommen 2003, für die Übung beibehalten)
fun calculateTax(brackets: List<TaxBracket>, taxpayer: Taxpayer): Int {
    val (married, nbChildren, salary) = taxpayer
    var shares = BigDecimal(nbChildren).divide(BigDecimal.TWO) + BigDecimal(if (married) 2 else 1)
    if (nbChildren >= 3) shares += BigDecimal("0.5")
    val income = BigDecimal("0.72") * BigDecimal(salary)
    val quotient = income.divide(shares, MathContext.DECIMAL64)
    // die erste Stufe, deren Grenze den Familienquotienten übersteigt, andernfalls die letzte
    val bracket = brackets.firstOrNull { quotient <= it.limit } ?: brackets.last()
    return (bracket.coeffR * income - bracket.coeffN * shares).toInt()
}

// ein Steuerpflichtiger
data class Taxpayer(val married: Boolean, val nbChildren: Int, val salary: Int)

// eine Steuerstufe
data class TaxBracket(val limit: BigDecimal, val coeffR: BigDecimal, val coeffN: BigDecimal) {
    companion object {
        fun parse(line: String): TaxBracket {
            val (limit, coeffR, coeffN) = line.split(":").map(::BigDecimal)
            return TaxBracket(limit, coeffR, coeffN)
        }
    }
}

Ergebnisse:

> gradlew -q run -Pmain=async33.Async33Kt
7 lines written to [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
2 - in sequence: total = 11,374,472,918 €, in 338 ms
2 - in parallel: total = 11,374,472,918 €, in 145 ms

Dasselbe Programm mit dem Namen einer nicht vorhandenen Steuerstufendatei als Argument (die Option [--args] der Gradle-Aufgabe [run] übergibt ihre Argumente an das Programm):

> gradlew -q run -Pmain=async33.Async33Kt --args="Missing.txt"
Error: NoSuchFileException : Missing.txt

Kommentare:

  • Zeilen 72–75: Die Verarbeitung ist eine Suspend-Funktion, deren Rumpf ein [coroutineScope]-Block ist. Die beiden Eingabedateien werden gleichzeitig von zwei Coroutinen gelesen, die von [async] auf dem Dispatcher [IO] gestartet werden und gewöhnliche blockierende Lesefunktionen verwenden ([useLines], [readLines]); die Berechnung wartet mit [await()] auf beide Lesevorgänge. Das Java-Programm musste die Berechnung als dritte Aufgabe starten, die beim Warten auf die beiden Lesevorgänge einen virtuellen Thread blockierte; hier ist die Berechnung einfach die Fortsetzung des Codes;
  • Zeilen 35–42: Das Hauptprogramm begrenzt die Verarbeitung mit [withTimeout] auf 10 Sekunden. Darüber hinaus würde die Verarbeitung abgebrochen – das heißt die beiden Lesevorgänge und die Berechnung –, ohne dass zusätzlicher Code erforderlich wäre: Das ist strukturierte Nebenläufigkeit. Der Ausdruck [return@runBlocking] verlässt das Lambda von [runBlocking] und damit das Programm (Kapitel 7: ein mit Label versehenes [return]);
  • Zeilen 44–46: Fehler werden an einer einzigen Stelle behandelt, im Hauptprogramm. Ein Lesefehler (fehlende Datei, falsche Zahl) lässt die lesende Coroutine fehlschlagen; der [coroutineScope]-Block bricht dann den anderen Lesevorgang ab und wirft die ursprüngliche Ausnahme erneut, die unverändert an das [catch] weitergereicht wird (zweites Ergebnis). Das Java-Programm erhielt diese Ausnahme früher zweifach in eine [ExecutionException] verpackt und musste sie in einer Schleife auspacken: Die strukturierte Nebenläufigkeit hat diesen Nachteil beseitigt, wie im Java-Kurs erläutert;
  • Zeile 33: Der Name der Steuerstufendatei ist das erste Argument des Programms, sofern vorhanden; andernfalls [getOrElse] liefert den vom Lambda berechneten Wert;
  • Zeilen 79–80: Das Lesen der Steuerstufen über die Zeilensequenz der Datei ([useLines]), die leere Zeilen überspringt;
  • Zeilen 83–97: Verarbeitung der Steuerzahler, die in eine Datei schreibt; sie übergibt sich daher selbst an den Dispatcher [IO], gemäß der Regel aus dem Programm [Async21.kt]. Jede Zeile wird durch den regulären Ausdruck in Zeile 29 validiert: entweder ein [y] oder ein [n], gefolgt von zwei positiven ganzen Zahlen, die durch Leerzeichen getrennt sind ([\s+]); der Raw String (["""…"""]) verhindert, dass die Backslashes verdoppelt werden. [matchEntire] liefert das Trefferergebnis, wenn die gesamte Zeile zum Ausdruck passt, [null] andernfalls; seine Eigenschaft [destructured] ermöglicht es, die drei Gruppen mit einer Destrukturierungszuweisung abzurufen, in [let]. Der Elvis-Operator ([?:]) liefert den Text „incorrect line“, wenn die Zeile nicht passt ([x] statt [y/n], negatives Gehalt);
  • Zeilen 101–109: die Steuerberechnung in [BigDecimal], geschrieben mit den Operatoren [+], [*], [-], und [<=], die Kotlin für diesen Typ erlaubt. Die Division des Einkommens durch die Anzahl der Anteile ist unter Umständen nicht exakt: Sie wird mit [divide] mit einer Genauigkeit von 16 signifikanten Stellen durchgeführt ([MathContext.DECIMAL64]), statt mit dem Operator [/], der den Quotienten auf die Anzahl der Dezimalstellen des Dividenden runden würde. Die erste Stufe, deren Grenze größer oder gleich dem Familienquotienten ist, wird mit [firstOrNull] gefunden, und der Elvis-Operator liefert die letzte Stufe, wenn keine der anderen passt. [toInt()] schneidet die Steuer auf den vollen Euro ab. Der Steuerzahler ist eine Datenklasse, die durch eine Destrukturierungsanweisung zerlegt wird;
  • die Ergebnisse liefern die Kontrollwerte für den roten Faden: 4.282 € für ein verheiratetes Paar mit 2 Kindern und einem Gehalt von 60.000 €, 2.959 € mit 3 Kindern und 11.519 € für eine alleinstehende Person ohne Kinder;
  • Zeilen 50–68: Eine Million fiktive Steuerzahler werden mit einem Pseudozufallszahlengenerator ([Random]) erzeugt, dessen fester Seed (2026) reproduzierbare Ergebnisse gewährleistet. Ihre Steuern werden zunächst sequentiell addiert ([sumOf], dann [Long] , damit der [Int] nicht überläuft). Anschließend werden sie in so viele Pakete ([chunked]) aufgeteilt, wie die Maschine Prozessoren hat; jedes Paket wird einer Coroutine des Dispatchers [Default] zugewiesen, der ebenso viele Threads wie Prozessoren hat, und [awaitAll()] berechnet die Teilsummen. Die Gesamtsumme ist dieselbe, und die Berechnung ist auf dieser Maschine mit zwei Prozessoren schneller (die scheinbare Beschleunigung ist sogar größer als 2, weil die erste Messung die Zeit enthält, die die JVM benötigt, um den Berechnungscode in Maschinencode zu kompilieren).

Die Berechnung der Steuer eines Steuerzahlers ist synchron: Sie umfasst keine I/O und dauert einige Mikrosekunden. Es wäre sinnlos – und sogar schädlich –, daraus eine suspendierbare Funktion zu machen oder sie an einen anderen Thread zu delegieren: Nur Aufgaben, die Wartezeiten enthalten, sollten asynchron gemacht werden. Dagegen kann eine große Anzahl unabhängiger Berechnungen auf die Prozessoren verteilt werden: Das ist die Aufgabe des Dispatchers [Default] (oder der parallelen Streams aus Kapitel 8) und nicht die des Dispatchers [IO] oder der virtuellen Threads, die Wartevorgänge abwickeln.

9.16. Die goldenen Regeln

Fassen wir die Regeln der asynchronen Programmierung mit Coroutinen zusammen:

  • Warten durch Suspendieren, nicht durch Blockieren: In einer Coroutine erfolgt das Warten über eine Suspend-Funktion ([delay], [await()], [send], [receive], [withContext] …), niemals über [Thread.sleep], [join()] oder [get()] eines [Future]. [runBlocking] gehört nur in das Hauptprogramm und in die Tests;
  • Eine blockierende Suspend-Funktion übergibt selbst die Kontrolle an den richtigen Dispatcher: Der blockierende Code (Dateien, JDBC, Java-Bibliotheken) wird mit [Dispatchers.IO] durch [withContext(Dispatchers.IO)] abgegeben, innerhalb der blockierenden Funktion; der Aufrufer kann sie dann von überall aufrufen. Eine API, die ein [CompletableFuture] zurückgibt, wird mit [await()] gekoppelt; eine Callback-basierte API wird mit [suspendCancellableCoroutine] gekoppelt;
  • Dispatchers.Default für Berechnungen, Dispatchers.IO für blockierende Wartevorgänge, Dispatchers.Main für die Oberfläche; eine [limitedParallelism(n)]-Sicht, um eine Anzahl von Threads für eine blockierende Ressource zu reservieren; virtuelle Threads als Dispatcher, wenn es Tausende blockierender Wartevorgänge gibt;
  • Jede Coroutine hat einen Parent: Coroutinen werden innerhalb eines Scopes gestartet ([coroutineScope], dem Scope einer Komponente, [viewModelScope] …), niemals in [GlobalScope]; ein Scope wartet auf seine Kinder; wenn ein Kind fehlschlägt, werden die anderen abgebrochen ([supervisorScope] macht sie unabhängig), und der Abbruch eines Parents bricht seine Kinder ab. Eine Funktion, die Coroutinen startet, ohne auf sie zu warten, ist eine Erweiterung von [CoroutineScope]; eine Funktion, die auf den Abschluss ihrer Arbeit wartet, ist eine [suspend]-Funktion;
  • Erst starten, dann warten: Um mehrere unabhängige Operationen gleichzeitig auszuführen, starten Sie alle ([async]) und warten dann auf sie ([awaitAll()]);
  • Der Abbruch ist kooperativ: Eine Coroutine hält an ihren Suspendierungspunkten an; eine lang laufende Berechnung prüft [isActive] oder ruft [ensureActive()] / [yield()] auf; eine [CancellationException] wird niemals verschluckt (Vorsicht bei [catch (e: Exception)] und [runCatching]); die Aufräumarbeiten einer abgebrochenen Coroutine, die suspendieren müssen, erfolgen in [withContext(NonCancellable)];
  • Begrenzen Sie die Wartezeiten: [withTimeout] und [withTimeoutOrNull] brechen die Operation selbst ab, nicht nur das Warten; ein [CompletableDeferred] mit Timeout muss von seinem Ersteller abgebrochen werden;
  • Begrenzen Sie gleichzeitige Operationen mit einem Semaphor ([withPermit]) oder einer festen Anzahl von Workern, die einen [Channel] lesen; [limitedParallelism] begrenzt Threads, nicht suspendierte Operationen;
  • Eine Folge von Werten ist ein Flow: kalt, bei Bedarf gesammelt, durch Operatoren transformiert; [flowOn] ändert den Dispatcher des Produzenten, [buffer] entkoppelt Produzent und Konsument, [catch] behandelt Fehler im Upstream. Heiße Quellen sind [Channel] (ein Konsument pro Wert), [SharedFlow] (alle Abonnenten) oder [StateFlow] (ein Status);
  • Keine Thread-Sperre um eine Suspendierung: [synchronized] und [ReentrantLock] dürfen einen Suspend-Aufruf nicht umschließen; verwenden Sie einen [Mutex] oder, besser noch, vermeiden Sie gemeinsamen Zustand (ein gemeinsames [Deferred], einen Channel, unveränderliche Daten).

Die folgende Tabelle fasst die Entsprechungen zwischen der Welt der Plattform-Threads und blockierenden Wartevorgänge (vorheriges Kapitel), der der virtuellen Threads und [CompletableFuture] (Java-Kurs) und der der Coroutinen zusammen:

Threads, blockierende Wartevorgänge
Virtuelle Threads, CompletableFuture
Coroutinen
[Thread.sleep(1000)] (blockiert den Thread)
[Thread.sleep(1000)] auf einem virtuellen Thread (gibt den Carrier frei)
[delay(1000)] (suspendiert die Coroutine)
[thread { … }] gefolgt von [join()]
[executor.submit { … }] dann [get()]; [supplyAsync { … }] dann [join()]
[launch { … }] gefolgt von [join()]; [async { … }] gefolgt von [await()]
Auf mehrere Threads warten ([join] in einer Schleife)
[invokeAll(...)], [allOf(...)], [anyOf(...)]
[awaitAll()], [coroutineScope], [select]
Callback-Methoden ([CompletionHandler])
[thenApply], [thenCompose], [thenCombine]
Der Code, der auf den Suspend-Aufruf folgt
[try / catch] um [get()] ([ExecutionException])
[exceptionally], [handle], [whenComplete]
[try / catch] (gewöhnlich), [CoroutineExceptionHandler]
[thread.interrupt()]
[future.cancel(true)]
[job.cancel()] (kooperativer Abbruch, an die Kinder propagiert)
[future.get(timeout, unit)]
[orTimeout(...)], [completeOnTimeout(...)]
[withTimeout(...)], [withTimeoutOrNull(...)]
Thread-Pool fester Größe
[Semaphore] ([java.util.concurrent])
[Semaphore] ([kotlinx.coroutines.sync]), [limitedParallelism(n)]
[BlockingQueue] (blockiert den Thread)
[BlockingQueue] auf virtuellen Threads, [SubmissionPublisher]
[Channel], [SharedFlow]
[Stream], [Iterator]
[Stream], eine von einem virtuellen Thread gelesene Sperre
[Flow]
[synchronized], [ReentrantLock]
[ReentrantLock]
[Mutex]
[ScheduledExecutorService]
[ScheduledExecutorService], [delayedExecutor]
[delay] in einer Schleife
—
[new CompletableFuture<>()], [complete]
[CompletableDeferred], [suspendCancellableCoroutine]
—
[StructuredTaskScope] (Preview)
[coroutineScope], [supervisorScope]

Die folgenden Kapitel wenden diese Regeln an: den Datenbankzugriff mit JDBC (Kapitel 10) und Hibernate (Kapitel 11), bei denen die API-Aufrufe blockierend sind und aus Coroutinen auf dem Dispatcher [IO] (oder auf virtuellen Threads) verwendet werden, den TCP-Server, der jeden Client über einen virtuellen Thread oder eine Coroutine bedient, und den Client [HttpClient] (Kapitel 12) sowie die Spring-Boot-Webservices und ihre Clients (Kapitel 13).