launch — essence, lancement fire-and-forget de coroutines et fonctionnement

Qu'est-ce que launch dans Kotlin Coroutines ?

launch est une fonction d'extension de Kotlin, disponible via l'import kotlinx.coroutines, qui crée une nouvelle coroutine dans un CoroutineScope donné. Contrairement aux fonctions normales, le code à l'intérieur de launch s'exécute concurrentiellement — la coroutine peut se suspendre sans bloquer un thread et reprendre plus tard.

Le builder launch est un bloc fondamental du modèle de coroutines de Kotlin. Il ne renvoie pas de valeur calculée mais retourne un objet Job qui permet de contrôler l'exécution de la coroutine. Toutes les coroutines filles lancées via launch à l'intérieur d'une autre coroutine sont liées à la coroutine mère.

Syntaxe et paramètres de launch

Le builder launch est défini comme une fonction inline avec plusieurs paramètres : CoroutineScope, CoroutineContext, CoroutineStart et un bloc suspend. Les paramètres ont des valeurs par défaut, ce qui rend launch pratique pour les scénarios typiques.

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

Le paramètre context accepte un CoroutineContext qui combine un dispatcher, un gestionnaire d'exceptions et un élément nommé. Le plus souvent, Dispatchers.IO, Dispatchers.Main ou SupervisorJob sont passés pour isoler les erreurs.

Job et gestion du cycle de vie

Job — l'objet retourné représentant le cycle de vie de la coroutine. Un Job peut être dans les états : New, Active, Completing, Completed, Cancelling, Cancelled. Chaque état reflète le statut d'exécution et permet de réagir aux changements.

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

println("Le Job est actif : ${job.isActive}")
delay(2500L)
job.cancel()
println("Le Job est annulé : ${job.isCancelled}")

Job supporte une hiérarchie : si une coroutine mère est annulée, toutes les coroutines filles sont automatiquement annulées. SupervisorJob modifie ce comportement — les coroutines filles ne sont pas annulées lorsque l'une d'elles échoue.

Concurrence structurée dans launch

La concurrence structurée signifie que chaque coroutine est lancée dans un CoroutineScope spécifique, et le scope ne se termine pas tant que toutes les coroutines filles n'ont pas fini leur travail. launch supporte pleinement ce principe — les coroutines lancées à l'intérieur d'une autre coroutine sont ses filles.

Appels launch imbriqués

Avec des appels launch imbriqués, un arbre de coroutines se forme. La coroutine mère attend la fin de toutes les coroutines filles, garantissant un ordre d'exécution prévisible et simplifiant la gestion des ressources.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Enfant 1 terminé")
        }
        launch {
            delay(500L)
            println("Enfant 2 terminé")
        }
        println("Tous les enfants terminent avant cette ligne")
    }
}

Ce comportement diffère de la concurrence basée sur les threads, où les threads fils ne sont pas liés au thread père. Dans les coroutines, la coroutine mère ne se termine pas tant que toutes les coroutines filles n'ont pas fini leur travail.

Gestion des exceptions dans launch

La gestion des exceptions dans launch dépend du type de Job. Pour un Job normal, les exceptions se propagent à la coroutine mère et l'annulent. Pour SupervisorJob ou SupervisorScope, les exceptions sont isolées — une erreur dans une coroutine fille n'affecte pas les autres.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Attrapé : ${e.message}")
    }
}
scope.launch {
    println("Cela continue de fonctionner grâce à SupervisorJob")
}

Pour la gestion globale des exceptions non capturées, CoroutineExceptionHandler est utilisé. Il intercepte les exceptions qui n'ont pas été traitées à l'intérieur de la coroutine et permet de journaliser l'erreur sans planter l'application.

Exemples d'utilisation de launch dans Android

Dans Android, launch est utilisé partout : de ViewModel à WorkManager. Le modèle principal est l'utilisation de lifecycleScope dans Fragment et viewModelScope dans ViewModel pour l'annulation automatique des coroutines à la fin du cycle de vie du composant.

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 annule automatiquement les coroutines lorsque la ViewModel est détruite. Cela élimine les fuites et garantit que les opérations en arrière-plan ne continuent pas après la perte du contexte. De plus, withContext peut être utilisé pour basculer entre les dispatchers.