Welche Möglichkeiten bietet Kotlin für die Arbeit mit…

Kotlin stellt Koroutinen bereit, um asynchrone Operationen zu vereinfachen, indem sie leichte Threads anbieten, die den Haupt-Thread nicht blockieren.

Wichtige Funktionen:

Suspensionsfunktionen: Funktionen mit dem Schlüsselwort suspend, die pausiert und wieder aufgenommen werden können. Sie blockieren nicht den Thread, auf dem sie ausgeführt werden.
```
suspend fun fetchData(): String {
    delay(1000) // Simuliert eine lange Operation
    return "Daten empfangen"
}
```
Koroutinen-Builder: Funktionen zum Starten von Koroutinen:
- launch: Startet eine neue Koroutine und gibt einen Job zurück (nicht blockierend).
```
GlobalScope.launch {
    println("Koroutine gestartet")
}
```
- async: Startet eine neue Koroutine und gibt ein Deferred<T> zurück (blockiert bei .await()).
```
val deferred = GlobalScope.async {
    fetchData()
}
// ...
val result = deferred.await() // Ergebnis abwarten
```
- runBlocking: Blockiert den aktuellen Thread bis zum Abschluss der Koroutine (verwendet in Brücken zwischen blockierendem und nicht-blockierendem Code, z.B. in Tests).
```
runBlocking {
    val data = fetchData()
    println(data)
}
```
Koroutine-Kontext: Ein Satz von Elementen, die das Verhalten der Koroutine bestimmen, einschließlich Dispatcher und Job.
- Dispatcher: Bestimmt den Thread oder Thread-Pool, auf dem die Koroutine ausgeführt wird.
Dispatchers: Eingebaute Objekte zur Thread-Verwaltung:
- Dispatchers.Default: Gemeinsamer Pool von Hintergrund-Threads.
- Dispatchers.IO: Optimiert für Ein- und Ausgabe (Festplatten-, Netzwerkoperationen).
- Dispatchers.Main: Haupt-UI-Thread (für Android, JavaFX usw.).
- Dispatchers.Unconfined: Führt die Koroutine im aktuellen Thread aus, kann aber nach einer Pause in jedem Thread wieder aufgenommen werden.
```
GlobalScope.launch(Dispatchers.IO) {
    // Wird im Ein-/Ausgabethread ausgeführt
}
```

Strukturierte Nebenläufigkeit: Prinzip, nach dem Koroutinen einen Elternteil (CoroutineScope) haben und beim Canceln des Elternteils automatisch abgebrochen werden. Verhindert Ressourcenlecks und vereinfacht das Lebenszyklusmanagement.

// CoroutineScope verwaltet automatisch Kind-Koroutinen
val scope = CoroutineScope(Dispatchers.Default)
val job = scope.launch {
    // ...
}
// Beim Canceln des Scopes werden alle Kind-Koroutinen abgebrochen
scope.cancel()

Kanäle: Für sichere Datenübertragung zwischen Koroutinen. Können sein:
- Unbuffered: Empfang erfolgt nur nach dem Senden.
- Buffered: Ermöglicht das Senden mehrerer Elemente vor dem Blockieren.
- Conflated: Speichert nur das zuletzt gesendete Element.
```
val channel = Channel<Int>()

scope.launch {
    for (x in 1..5) channel.send(x)
    channel.close()
}

scope.launch {
    for (y in channel) println(y)
}
```

Flow: Datenstrom, der mehrere Werte asynchron ausstrahlen kann. Ähnlich wie RxJava Observable, aber leichter und mit Koroutinen integriert.

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i) // Wert senden
    }
}

runBlocking {
    simpleFlow().collect { value -> println(value) } // Werte konsumieren
}

Diese Funktionen ermöglichen das Schreiben von asynchronem Code im imperativen Stil, was ihn lesbarer und wartbarer macht im Vergleich zur Verwendung von Callbacks oder Future.

Welche Möglichkeiten bietet Kotlin für die Arbeit mit asynchronen Operationen?