Welke elementen van multithreading biedt Kotlin…

Kotlin biedt de volgende elementen voor gelijktijdigheid:

Coroutines: Lichtgewicht threads gebaseerd op suspenderende functies. Ze maken asynchrone en niet-blokkerende uitvoering van code mogelijk.

Coroutine-builders: Functies die coroutines starten. Belangrijkste: launch (start een coroutine zonder waarde terug te geven), async (start een coroutine en geeft een Deferred terug, dat kan worden afgewacht om het resultaat te krijgen).

// Voorbeeld van gebruik van launch
GlobalScope.launch {
    println("Hallo vanuit de coroutine ${Thread.currentThread().name}")
}

// Voorbeeld van gebruik van async
val deferred = GlobalScope.async {
    delay(1000) // Simuleer een lange operatie
    "Resultaat"
}
val result = runBlocking { deferred.await() } // Wacht op resultaat

Dispatchers: Bepalen op welke threadpool de coroutine wordt uitgevoerd. Belangrijkste:
- Dispatchers.Default: Algemene threadpool voor CPU-intensieve taken.
- Dispatchers.IO: Threadpool voor blokkerende input/output operaties (bestanden, netwerk).
- Dispatchers.Main: Dispatcher voor de gebruikersinterface thread op geschikte platforms (Android, Swing).
- Dispatchers.Unconfined: De coroutine start in de huidige thread, maar kan worden hervat in elke thread.
```
GlobalScope.launch(Dispatchers.IO) {
    // Uitvoeren van input/output
}
```
runBlocking: Functie die een coroutine bouwt en de huidige thread blokkeert tot de coroutine voltooid is. Wordt gebruikt om blokkerende en niet-blokkerende code te combineren, vaak in tests of main-functies.
```
runBlocking {
    launch {
        delay(500)
        println("Gereed in ${Thread.currentThread().name}")
    }
    println("Gestart in ${Thread.currentThread().name}")
}
```
suspend functies: Functies waarvan de uitvoering kan worden onderbroken en hervat. Alleen aan te roepen vanuit andere suspend functies of coroutine-builders.
```
suspend fun doSomething() {
    delay(100) // Voorbeeld van onderbreking
}
```

Job: Handle voor een lopende coroutine. Biedt methoden om de levenscyclus van de coroutine te beheren (annuleren, wachten tot het klaar is).

val job = GlobalScope.launch {
   // Lange operatie
}
job.cancel() // Annuleer de coroutine
runBlocking { job.join() } // Wacht tot het klaar is

CoroutineScope: Bepaalt de scope voor coroutines. Coroutines gestart in een bepaalde scope worden automatisch geannuleerd bij het annuleren van de scope. Helpt bij het beheren van de levenscyclus van coroutines.
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Coroutine in deze scope
}
scope.cancel() // Annuleer alle coroutines in deze scope
```

Kanalen (Channel): Primitive voor veilige gegevensoverdracht tussen coroutines. Kanalen kunnen unidirectioneel (alleen verzenden of ontvangen) of bidirectioneel zijn.

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Belangrijk om kanaal te sluiten
    }
    launch {
        for (y in channel) println(y)
    }
}

Mutex (Mutex): Synchronisatieprimitive die exclusieve toegang tot een gedeelde bron garandeert. Zorgt voor threadveiligheid, waardoor slechts één coroutine op een bepaald moment de mutex kan bezitten.

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

val mutex = Mutex()
var counter = 0

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

Toestanden (StateFlow, SharedFlow): Primitive voor werken met datastromen in de context van reactieve programmering en gelijktijdigheid. StateFlow vertegenwoordigt een "koud" stroom met de huidige toestand, en SharedFlow een "hete" stroom voor breedcasten van gegevens.

Welke elementen van multithreading biedt Kotlin?