launch — essentie, fire-and-forget starten van coroutines en hoe het werkt

Wat is launch in Kotlin Coroutines?

launch — is een Kotlin-uitbreidingsfunctie, beschikbaar via import kotlinx.coroutines, die een nieuwe coroutine maakt in een opgegeven CoroutineScope. In tegenstelling tot gewone functies wordt code binnen launch gelijktijdig uitgevoerd — de coroutine kan worden onderbroken (suspend) zonder de thread te blokkeren en later worden hervat.

De launch-builder is een fundamenteel bouwblok van het coroutine-model van Kotlin. Het geeft geen berekende waarde terug, maar retourneert een Job-object waarmee de uitvoering van de coroutine kan worden gecontroleerd. Alle kind-coroutines die via launch binnen een andere coroutine worden gestart, zijn gekoppeld aan de ouder.

Syntaxis en parameters van launch

De launch-builder is gedefinieerd als een inline-functie met meerdere parameters: CoroutineScope, CoroutineContext, CoroutineStart en suspend-block. De parameters hebben standaardwaarden, wat launch handig maakt voor typische scenario's.

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

De parameter context accepteert een CoroutineContext die de dispatcher, uitzonderingshandler en een benoemd element combineert. Meestal worden Dispatchers.IO, Dispatchers.Main of SupervisorJob voor foutisolatie doorgegeven.

Job en levenscyclusbeheer

Job — het geretourneerde object dat de levenscyclus van de coroutine vertegenwoordigt. Job kan zich in de volgende toestanden bevinden: New, Active, Completing, Completed, Cancelling, Cancelled. Elke toestand weerspiegelt de uitvoeringsstatus en maakt reactie op wijzigingen mogelijk.

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("Voortgang: $i")
    }
}

println("Job is actief: ${job.isActive}")
delay(2500L)
job.cancel()
println("Job is geannuleerd: ${job.isCancelled}")

Job ondersteunt hiërarchie: als de oudercoroutine wordt geannuleerd, worden alle kind-coroutines automatisch geannuleerd. SupervisorJob verandert dit gedrag — kind-coroutines worden niet geannuleerd bij een fout van een van hen.

Gestructureerde concurrentie in launch

Gestructureerde concurrentie betekent dat elke coroutine in een specifieke CoroutineScope wordt gestart en de scope niet eindigt totdat alle kind-coroutines hun werk hebben voltooid. launch ondersteunt dit principe volledig — coroutines die binnen een andere coroutine worden gestart, zijn de kinderen ervan.

Geneste launch-aanroepen

Bij geneste launch-aanroepen ontstaat een boom van coroutines. De oudercoroutine wacht op voltooiing van alle kinderen, wat een voorspelbare uitvoeringsvolgorde garandeert en resourcebeheer vereenvoudigt.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Kind 1 voltooid")
        }
        launch {
            delay(500L)
            println("Kind 2 voltooid")
        }
        println("Alle kinderen voltooid vóór deze regel")
    }
}

Dit gedrag verschilt van thread-gebaseerde concurrentie, waar kind-threads niet aan de ouder zijn gekoppeld. In coroutines eindigt de ouder niet totdat alle kinderen hun werk hebben voltooid.

Uitzonderingsafhandeling in launch

Uitzonderingsafhandeling in launch hangt af van het type Job. Voor een gewone Job verspreiden uitzonderingen zich naar de oudercoroutine en annuleren deze. Voor SupervisorJob of SupervisorScope worden uitzonderingen geïsoleerd — een fout in een kind-coroutine heeft geen invloed op de andere.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Opgevangen: ${e.message}")
    }
}
scope.launch {
    println("Dit werkt nog steeds dankzij SupervisorJob")
}

Voor globale afhandeling van niet-afgevangen uitzonderingen wordt CoroutineExceptionHandler gebruikt. Het vangt uitzonderingen die niet binnen de coroutine zijn afgehandeld en maakt het mogelijk de fout te loggen zonder crash van de applicatie.

Voorbeelden van launch in Android

In Android wordt launch overal toegepast: van ViewModel tot WorkManager. Het belangrijkste patroon is het gebruik van lifecycleScope in Fragment en viewModelScope in ViewModel voor automatische annulering van coroutines aan het einde van de levenscyclus van het component.

class ProfileViewModel : ViewModel() {
    private val repository = UserRepository()

    fun loadProfile(userId: String) {
        viewModelScope.launch(Dispatchers.IO) {
            val profile = repository.fetchProfile(userId)
            withContext(Dispatchers.Main) {
                _profileState.update { it.copy(profile = profile) }
            }
        }
    }
}

viewModelScope annuleert automatisch coroutines bij vernietiging van de ViewModel. Dit elimineert geheugenlekken en garandeert dat achtergrondoperaties niet worden voortgezet na verlies van context. Aanvullend kan withContext worden gebruikt om tussen dispatchers te schakelen.