Welke mogelijkheden biedt Kotlin voor het werken met…

Kotlin biedt coroutines om asynchrone operaties te vereenvoudigen, met lichtgewicht threads die de hoofdthread niet blokkeren.

Belangrijkste functies:

Suspension Functions: Functies met het sleutelwoord suspend, die onderbroken en hervat kunnen worden. Ze blokkeren niet de thread waarop ze worden uitgevoerd.
```
suspend fun fetchData(): String {
    delay(1000) // Simuleert een lange operatie
    return "Data ontvangen"
}
```
Coroutine Builders: Functies om coroutines te starten:
- launch: Start een nieuwe coroutine en geeft een Job terug (niet-blokkerend).
```
GlobalScope.launch {
    println("Coroutine gestart")
}
```
- async: Start een nieuwe coroutine en geeft een Deferred<T> terug (.await() blokkeert).
```
val deferred = GlobalScope.async {
    fetchData()
}
// ...
val result = deferred.await() // Wacht op resultaat
```
- runBlocking: Blokkeert de huidige thread tot de coroutine is voltooid (gebruikt in bruggen tussen blokkerende en niet-blokkerende code, bijvoorbeeld in tests).
```
runBlocking {
    val data = fetchData()
    println(data)
}
```
Coroutine Context: Een set elementen die het gedrag van de coroutine bepalen, inclusief Dispatcher en Job.
- Dispatcher: Bepaalt de thread of threadpool waar de coroutine wordt uitgevoerd.
Dispatchers: Ingebouwde objecten voor threadbeheer:
- Dispatchers.Default: Gedeelde pool van achtergrondthreads.
- Dispatchers.IO: Geoptimaliseerd voor invoer/uitvoer (schijf-, netwerkoperaties).
- Dispatchers.Main: Hoofd UI-thread (voor Android, JavaFX, etc.).
- Dispatchers.Unconfined: Voert de coroutine uit in de huidige thread, maar kan hervatten in elke thread na onderbreking.
```
GlobalScope.launch(Dispatchers.IO) {
    // Voert uit in invoer/uitvoer thread
}
```

Gestructureerde Concurrency: Principe waarbij coroutines een ouder (CoroutineScope) hebben en automatisch worden geannuleerd bij annulering van de ouder. Voorkomt resource leaks en vereenvoudigt levenscyclusbeheer.

// CoroutineScope beheert automatisch kind-coroutines
val scope = CoroutineScope(Dispatchers.Default)
val job = scope.launch {
    // ...
}
// Bij annulering van scope worden alle kind-coroutines geannuleerd
scope.cancel()

Kanalen: Voor veilige gegevensoverdracht tussen coroutines. Ze kunnen zijn:
- Unbuffered: Ontvangst gebeurt pas na verzending.
- Buffered: Stuur meerdere elementen voordat blokkering optreedt.
- Conflated: Slaat alleen het laatste verzonden element op.
```
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: Gegevensstroom die meerdere waarden asynchroon kan uitzenden. Vergelijkbaar met RxJava Observable, maar lichter en geïntegreerd met coroutines.

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

runBlocking {
    simpleFlow().collect { value -> println(value) } // Verbruik van waarden
}

Deze functies maken het mogelijk om asynchrone code in imperatieve stijl te schrijven, waardoor deze leesbaarder en onderhoudsvriendelijker wordt dan met callbacks of Future.

Welke mogelijkheden biedt Kotlin voor het werken met asynchrone operaties?