Hoe zou je een niet-annuleerbare coroutine implementeren?

Om een niet-annuleerbare coroutine te implementeren, kun je de context NonCancellable gebruiken.

import kotlinx.coroutines.*

suspend fun performNonCancellableOperation() {
    coroutineScope {
        launch {
            // Deze coroutine kan worden geannuleerd
            delay(1000)
            println("Deze coroutine is uitgevoerd")
        }

        withContext(NonCancellable) {
            // Deze coroutine wordt niet geannuleerd, zelfs niet als de bovenliggende scope wordt geannuleerd
            try {
                delay(2000) // Simulatie van een langdurige operatie
                println("Niet-annuleerbare operatie voltooid")
            } catch (e: CancellationException) {
                // De coroutine kan nog steeds CancellationException ontvangen
                // in bepaalde gevallen (bijvoorbeeld bij het sluiten van de applicatie),
                // maar wordt niet reactief geannuleerd op de annulering van de parent.
                println("Niet-annuleerbare operatie werd geannuleerd: ${e.message}")
            } finally {
                // Deze blok wordt uitgevoerd zelfs bij annulering
                println("Niet-annuleerbare operatie beëindigd (finally)")
            }
        }
    }
}

Het gebruik van NonCancellable is handig voor het uitvoeren van afsluitende operaties, zoals het opslaan van gegevens of het vrijmaken van bronnen, wanneer de coroutine is geannuleerd.

Het is belangrijk om te onthouden dat NonCancellable de coroutine ongevoelig maakt voor annulering uit de context, maar deze kan nog steeds worden geannuleerd bij het afsluiten van de virtuele machine of in andere extreme gevallen. Bovendien, als binnen withContext(NonCancellable) een suspende functie wordt aangeroepen die zelf controleert op annulering (bijvoorbeeld delay), kan deze een CancellationException werpen. Daarom wordt aanbevolen om try-catch-finally te gebruiken om dergelijke situaties af te handelen.