Comment le scope suit-il l'annulation d'une…

Scope suit la annulation d’une coroutine à l’aide de l’objet Job. Chaque CoroutineScope possède un Job associé.

Lorsqu’une nouvelle coroutine est créée dans un CoroutineScope, elle reçoit le Job de ce scope comme son Job parent.

Le mécanisme de suivi de l’annulation fonctionne comme suit :

Annulation du Scope : Lorsqu’on appelle cancel() sur le Job du scope, il annule récursivement tous ses Job enfants.
Annulation d’une Coroutine Enfant : Lorsqu’une coroutine enfant est annulée (par exemple, via withContext(NonCancellable)) ou en cas d’exception non gérée, elle en informe son Job parent. Le Job parent (du scope) peut à son tour annuler d’autres coroutines enfants.
Annulation Coopérative : Les coroutines doivent être coopératives vis-à-vis de l’annulation. Cela signifie que dans la coroutine, le code doit vérifier périodiquement si elle a été annulée pour terminer son travail proprement. Les fonctions suspendues (comme delay, opérations d’E/S) vérifient automatiquement l’état du Job.

Le code peut vérifier explicitement l’annulation en utilisant isActive ou ensureActive():

// Exemple de vérification de l’activité d’une coroutine
suspend fun fetchData() = coroutineScope {
    launch {
        while (isActive) {
            // Effectuer une opération longue
            delay(100) // point de suspension - vérifie automatiquement l’annulation

            // Ou vérifier explicitement
            if (!isActive) {
                break // Sortir de la boucle en cas d’annulation
            }
        }
        println("fetchData coroutine terminée")
    }
}

L’utilisation de ensureActive() lance une CancellationException en cas d’annulation :

// Utilisation de ensureActive()
suspend fun processData() {
    // ... un travail quelconque ...
    ensureActive() // Lancerait CancellationException si la coroutine est annulée
    // ... continuer le travail uniquement si la coroutine est active ...
}

CancellationException est la méthode standard pour propager le signal d’annulation. Il ne doit pas être considéré comme une erreur dans le contexte de l’annulation des coroutines.

Scope, possédant un Job, crée une hiérarchie "parent-enfant" de Job, permettant de propager le signal d’annulation du parent aux enfants. C’est la pierre angulaire du parallélisme structuré dans les coroutines.

Comment le scope suit-il l'annulation d'une coroutine?