Door welke mechanismen wordt coöperatief multitasken geïmplementeerd in coroutines?

In coroutines wordt coöperatief multitasking geïmplementeerd door middel van de volgende mechanismen:

• Suspension Points: De coroutine kan "onderbroken" worden op bepaalde punten (suspension points), zonder de thread te blokkeren. Dit gebeurt bij het aanroepen van suspend functies. Tijdens de onderbreking is de thread waarin de coroutine werd uitgevoerd vrij om andere taken uit te voeren.

• Dispatchers: Coroutines gebruiken Dispatchers om de threadpool te bepalen waarop ze worden uitgevoerd. Een coroutine kan op één thread worden onderbroken en op een andere worden hervat.

• Continuatie: Elke keer dat een coroutine wordt onderbroken, wordt een Continuation object gemaakt dat de toestand van de coroutine op dat moment opslaat. Wanneer de coroutine wordt hervat, gebruikt deze dit object om de toestand te herstellen en verder te gaan vanaf de onderbroken plek.

• Samenwerking: De ontwikkelaar geeft expliciet de suspend-punten aan in de code. Dit maakt multitasking "coöperatief" – de coroutine geeft vrijwillig de controle aan een andere coroutine of taak op bepaalde punten, in plaats van door het besturingssysteem te worden onderbroken zoals bij preemptive multitasking.

• Gestructureerde concurrency: Coroutines zijn gekoppeld aan een CoroutineScope. Dit maakt het mogelijk om een groep coroutines gelijktijdig te annuleren en garandeert dat alle kind-coroutines worden voltooid bij het beëindigen van de ouder scope.

// Voorbeeld van een suspend-functie die een suspension point creëert
suspend fun fetchDataFromNetwork(): String {
    // Simulatie van een netwerkverzoek
    delay(1000) // Dit is een suspend-functie - suspension point
    return "Data ontvangen"
}

fun main() = runBlocking {
    // runBlocking creëert een CoroutineScope en blokkeert de huidige thread tot de coroutine is voltooid
    println("Begin")

    launch {
        // Start een coroutine op een andere thread (of dezelfde, afhankelijk van de dispatcher)
        val data = fetchDataFromNetwork() // Hier kan de coroutine worden onderbroken
        println("Ontvangen: $data")
    }

    println("Einde (de hoofdthread wordt niet geblokkeerd door fetchDataFromNetwork)")
    // De hoofdthread kan andere taken uitvoeren terwijl fetchDataFromNetwork wacht
}