Welke mechanismen biedt Kotlin voor het werken met…

Coroutines (Coroutines): Lichtgewichtige threads die het mogelijk maken om asynchrone code in imperatieve stijl te schrijven, en blokkades te vermijden. Gebaseerd op hervatbare functies en niet gekoppeld aan native threads.
Dispatchers: Bepalen de thread of threadpool waarop de coroutine wordt uitgevoerd.
- Dispatchers.Default: Voor resource-intensieve taken (bijvoorbeeld CPU-bound).
- Dispatchers.IO: Voor I/O-operaties (bijvoorbeeld netwerkverzoeken, werken met bestanden).
- Dispatchers.Main: Voor het uitvoeren van code op de hoofdthread (bijvoorbeeld UI-updates in een Android-app).
- Dispatchers.Unconfined: Voert de coroutine uit op de huidige thread tot de eerste aanroep van een suspend-functie.
Suspend-functies: Functies die gepauzeerd en later hervat kunnen worden. Gemarkeerd met de modifier suspend.
Context: Bevat informatie over de coroutine, zoals de dispatcher, job en exception handler.
Job: Vertegenwoordigt de levenscyclus van de coroutine (gestart, actief, voltooid, geannuleerd). Maakt het beheer van de coroutine mogelijk (annuleren, wachten op voltooiing).
Scope: Bepaalt het bereik van de coroutines en beheert hun levenscyclus.
MutableStateFlow / SharedFlow: In de bibliotheek kotlinx.coroutines.flow, maken ze veilige gegevensuitwisseling tussen coroutines mogelijk.
Mutex: Synchronisatieprimitive voor het beschermen van kritieke secties.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Voorbeeld van gebruik van coroutines en dispatcher
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("Werkende coroutine: $i")
            delay(100) // Niet-blokkerende vertraging
        }
    }
    println("Coroutine gestart")
    job.join() // Wacht tot de coroutine klaar is
    println("Coroutine voltooid")
}

// Voorbeeld suspend-functie
suspend fun fetchData(): String {
    delay(1000) // Simulatie van een netwerkverzoek
    return "Data ontvangen"
}

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}

Welke mechanismen biedt Kotlin voor het werken met parallelle berekeningen?