Welke hoofdklassen bestaan er in Kotlin Coroutines…

Belangrijkste klassen en concepten in Kotlin Coroutines:

CoroutineScope: Bepaalt de levenscyclus van de coroutines die binnen hem worden gestart. Maakt het mogelijk om alle kind-coroutines te annuleren.
Job: Vertegenwoordigt een handle naar een coroutine. Maakt het mogelijk om de status te volgen, te wachten op voltooiing, te annuleren.
Deferred: Een speciaal type Job dat een waarde vertegenwoordigt die later beschikbaar zal zijn. Gebruikt voor asynchrone berekeningen die een resultaat teruggeven. Het resultaat kan worden verkregen met de .await() functie.
Dispatcher: Bepaalt de thread of threadpool waarop de coroutine wordt uitgevoerd. De belangrijkste dispatchers:
- Dispatchers.Default: Geoptimaliseerd voor CPU-intensieve taken. Gebruikt een gedeelde threadpool.
- Dispatchers.IO: Geoptimaliseerd voor I/O-operaties (netwerk, schijf). Gebruikt een geschikte hoeveelheid threads.
- Dispatchers.Main: De hoofd-UI-thread. Voor het bijwerken van de UI. Beschikbaar op Android-platforms en andere met de juiste afhankelijkheid.
- Dispatchers.Unconfined: Start de coroutine in de huidige thread, maar hervat deze in elke thread die de suspending-functie hervat.
Suspending function: Functie gemarkeerd met het suspend-woord dat kan worden gepauzeerd en later hervat. Kan andere suspending-functies aanroepen.
runBlocking: Blokkeert de huidige thread totdat alle coroutines in zijn scope zijn voltooid. Wordt voornamelijk gebruikt voor testen en in de main.
launch: Start een nieuwe coroutine zonder de huidige thread te blokkeren en geeft een Job terug.
async: Start een nieuwe coroutine zonder de huidige thread te blokkeren en geeft een Deferred terug.

Voorbeeld van gebruik:

// Voorbeeld van gebruik van CoroutineScope, launch en Dispatchers.IO
import kotlinx.coroutines.*

fun main() = runBlocking {
    // Aanmaken van CoroutineScope
    val scope = CoroutineScope(Dispatchers.IO)

    // Starten van een coroutine in de IO dispatcher
    val job: Job = scope.launch {
        // Uitvoeren van een netwerkverzoek of andere I/O-operatie
        delay(1000) // Simulatie van werk
        println("Coroutine voltooid in ${Thread.currentThread().name}")
    }

    // Wachten op de coroutine
    job.join()
    println("Main functie voltooid")
}

// Voorbeeld van gebruik van async en Deferred
import kotlinx.coroutines.*

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

    // Wachten op resultaat
    val result = deferredSum.await()
    println("Resultaat is: $result")
}

Welke hoofdklassen bestaan er in Kotlin Coroutines?