Wat is een coroutine in Kotlin en hoe werkt het?

De coroutine in Kotlin is een lichte uitvoeringsunit die het mogelijk maakt om asynchrone, niet-blokkerende code op een meer leesbare en sequentiële manier te schrijven. Het lijkt op een thread, maar is veel lichter en kan in grote aantallen worden gemaakt.

Belangrijke componenten en werkingsprincipes:

• Suspend-functies: Functies gemarkeerd met het sleutelwoord suspend, die hun uitvoering kunnen onderbreken zonder de thread te blokkeren waarop ze worden uitgevoerd. Wanneer een suspend-functie haar "wacht"-operatie (bijvoorbeeld een netwerkverzoek) voltooit, kan ze de uitvoering hervatten vanaf waar ze was onderbroken.
• Context (Coroutine-context): Een verzameling elementen die het gedrag van de coroutine regelen. Inclusief:
  • Job: Descriptor van de coroutine, waarmee je de levenscyclus kunt beheren (annuleren, wachten tot voltooiing).
  • CoroutineDispatcher: Bepaalt op welke thread(s) de coroutine wordt uitgevoerd. Maakt het mogelijk om tussen threads te schakelen.
  • CoroutineName: Optionele naam voor debugging.
  • CoroutineExceptionHandler: Handler voor ongeregelde uitzonderingen.
• Builders: Functies die de uitvoering van coroutines starten:
  • launch: Start een nieuwe coroutine zonder resultaat terug te geven. Geeft een Job.
  • async: Start een nieuwe coroutine die een resultaat (Deferred) teruggeeft. Het resultaat wordt verkregen met .await().
  • runBlocking: Blokkerende builder, vooral gebruikt voor testen of integratie met blokkerende code.

Hoe het onder de motorkap werkt:

Coroutines maken geen aparte threads voor elke taak. In plaats daarvan, wanneer een suspend-functie wordt onderbroken, genereert de compiler code die de huidige staat van de berekeningen opslaat. Wanneer het resultaat beschikbaar is, wordt de coroutine hervat op een van de door CoroutineDispatcher beheerde threads. Dit wordt bereikt door suspend-functies om te zetten in asynchrone oproepen met continuaties, waardoor één thread meerdere coroutines kan uitvoeren en tussen hen kan schakelen bij onderbreking.

Voorbeeld:

import kotlinx.coroutines.*

fun main() = runBlocking { // Blokkeert de huidige thread tot de coroutine binnen runBlocking is voltooid
    println("Eerst")

    launch { // Start een nieuwe coroutine op de achtergrond
        delay(1000L) // Niet-blokkerende vertraging van 1 seconde
        println("Na de vertraging")
    }

    println("Vervolgens") // Deze regel wordt uitgevoerd voordat de launch coroutine eindigt
}

De uitvoer van deze code zal zijn:

Eerst
Vervolgens
Na de vertraging

Dit toont de niet-blokkerende aard van launch en delay.