Come lo scope traccia l'annullamento di una coroutine?

Scope monitora l'annullamento di una coroutine tramite l'oggetto Job. Ogni CoroutineScope ha un Job associato.

Quando viene creata una nuova coroutine all'interno di un CoroutineScope, essa riceve il Job di questo scope come suo Job genitore.

Il meccanismo di monitoraggio dell'annullamento funziona come segue:

1. Annullamento dello Scope: Quando si chiama cancel() sul Job dello scope, questo annulla ricorsivamente tutti i suoi Job figli.
2. Annullamento di una Coroutine Figlia: Quando una coroutine figlia viene annullata (ad esempio, tramite withContext(NonCancellable)) o in caso di un'eccezione non gestita, questa informa il suo Job genitore. Il Job genitore (dello scope) può a sua volta annullare altre sue coroutine figlie.
3. Annullamento Cooperativo: Le coroutines devono essere cooperative rispetto all'annullamento. Ciò significa che all'interno della coroutine, il codice deve verificare periodicamente se è stata annullata per terminare correttamente il proprio lavoro. Le funzioni suspend (come delay, operazioni di I/O) verificano automaticamente lo stato del Job.

Il codice può verificare esplicitamente l'annullamento usando isActive o ensureActive():

// Esempio di verifica dell'attività di una coroutine
suspend fun fetchData() = coroutineScope {
    launch {
        while (isActive) {
            // Esegui qualche operazione lunga
            delay(100) // punto di sospensione - verifica automaticamente l'annullamento

            // Oppure verifica esplicitamente
            if (!isActive) {
                break // Esci dal ciclo in caso di annullamento
            }
        }
        println("fetchData coroutine terminata")
    }
}

L'uso di ensureActive() genera una CancellationException in caso di annullamento:

// Uso di ensureActive()
suspend fun processData() {
    // ... qualche lavoro ...
    ensureActive() // Genera CancellationException se la coroutine è stata annullata
    // ... continuare il lavoro solo se la coroutine è attiva ...
}

CancellationException è il metodo standard per propagare il segnale di annullamento. Non dovrebbe essere considerato un errore nel contesto dell'annullamento delle coroutines.

Lo scope, possedendo un Job, crea una gerarchia "genitore-figlio" di Job, che permette di propagare il segnale di annullamento dal genitore ai figli. Questo è il fondamento del parallelismo strutturato nelle coroutines.