Welche Hauptklassen gibt es in Kotlin Coroutines…

Hauptklassen und Konzepte in Kotlin Coroutines:

CoroutineScope: Definiert den Lebenszyklus der innerhalb davon gestarteten Koroutinen. Ermöglicht das Abbrechen aller Kind-Koroutinen.
Job: Repräsentiert einen Handle zu einer Koroutine. Ermöglicht das Verfolgen ihres Zustands, das Warten auf deren Abschluss, das Abbrechen.
Deferred: Ein spezieller Typ von Job, der einen Wert repräsentiert, der später verfügbar sein wird. Wird für asynchrone Berechnungen verwendet, die ein Ergebnis zurückgeben. Das Ergebnis kann mit der Funktion .await() abgerufen werden.
Dispatcher: Bestimmt den Thread oder Thread-Pool, in dem die Koroutine ausgeführt wird. Die Haupt-Dispatcher:
- Dispatchers.Default: Optimiert für CPU-intensive Aufgaben. Verwendet einen gemeinsamen Thread-Pool.
- Dispatchers.IO: Optimiert für I/O-Operationen (Netzwerk, Festplatte). Verwendet eine angemessene Anzahl von Threads.
- Dispatchers.Main: Der Haupt-UI-Thread. Für UI-Updates. Auf Plattformen wie Android verfügbar.
- Dispatchers.Unconfined: Startet die Koroutine im aktuellen Thread, setzt sie aber in jedem Thread fort, der die suspending-Funktion wieder aufnimmt.
Suspending function: Funktion, die mit dem Schlüsselwort suspend markiert ist und pausiert und später wieder aufgenommen werden kann. Kann andere suspending-Funktionen aufrufen.
runBlocking: Blockiert den aktuellen Thread, bis alle Koroutinen in ihrem Geltungsbereich beendet sind. Wird hauptsächlich für Tests und im main-Block verwendet.
launch: Startet eine neue Koroutine, ohne den aktuellen Thread zu blockieren, und gibt ein Job zurück.
async: Startet eine neue Koroutine, ohne den aktuellen Thread zu blockieren, und gibt ein Deferred zurück.

Beispiel für die Verwendung:

// Beispiel für die Verwendung von CoroutineScope, launch und Dispatchers.IO
import kotlinx.coroutines.*

fun main() = runBlocking {
    // Erstellen eines CoroutineScope
    val scope = CoroutineScope(Dispatchers.IO)

    // Starten einer Koroutine im IO-Dispatcher
    val job: Job = scope.launch {
        // Ausführen einer Netzwerkabfrage oder einer anderen I/O-Operation
        delay(1000) // Simulation der Arbeit
        println("Koroutine beendet in ${Thread.currentThread().name}")
    }

    // Warten auf Abschluss der Koroutine
    job.join()
    println("Main-Funktion beendet")
}

// Beispiel für die Verwendung von async und Deferred
import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredSum: Deferred<Int> = async {
        delay(500)
        1 + 1
    }

    // Auf das Ergebnis warten
    val result = deferredSum.await()
    println("Ergebnis ist: $result")
}

Welche Hauptklassen gibt es in Kotlin Coroutines?