Pulizia con finally e NonCancellable
Rilasci le risorse nelle coroutine cancellate usando finally e withContext(NonCancellable).
Pulizia con finally e NonCancellable è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.
Cancellazione e finally
Quando una coroutine viene cancellata, i punti di sospensione generano CancellationException. Il codice nei blocchi finally viene sempre eseguito, ma il blocco finally stesso viene eseguito in un contesto di coroutine già cancellato.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
delay(1000)
} finally {
println("finally: cleaning up")
}
}
delay(50)
job.cancel()
job.join()
}Problema: sospensione in finally
Se prova a eseguire delay o un'altra sospensione all'interno di finally in una coroutine cancellata, l'operazione genera immediatamente un'eccezione perché il contesto è già cancellato.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
delay(1000)
} finally {
// delay(100) // throws CancellationException here!
println("Sync cleanup OK; async cleanup needs NonCancellable")
}
}
delay(50); job.cancel(); job.join()
}withContext(NonCancellable)
Racchiuda le chiamate di sospensione in finally con withContext(NonCancellable) per eseguirle in un contesto non cancellabile anche dopo la cancellazione del genitore.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
delay(1000)
} finally {
withContext(NonCancellable) {
delay(100) // OK: runs despite cancellation
println("Async cleanup complete")
}
}
}
delay(50); job.cancel(); job.join()
}Quando utilizzare NonCancellable
Utilizzi NonCancellable per chiudere connessioni al DB, svuotare i log, inviare eventi di analytics o eseguire qualsiasi operazione di pulizia asincrona che debba essere completata indipendentemente dalla cancellazione.
import kotlinx.coroutines.*
suspend fun closeConnection() {
println("Closing DB connection...")
delay(50) // simulate async close
println("Connection closed")
}
fun main() = runBlocking {
val job = launch {
try { delay(1000) }
finally { withContext(NonCancellable) { closeConnection() } }
}
delay(50); job.cancel(); job.join()
}NonCancellable non è uno scope
NonCancellable è un Job che può essere passato a withContext. Non lo utilizzi direttamente come scope per coroutine: lo utilizzi solo per la pulizia in finally.
import kotlinx.coroutines.*
fun main() = runBlocking {
// WRONG usage:
// launch(NonCancellable) { ... } // launches a coroutine that cannot be cancelled
// RIGHT usage:
launch {
try { delay(500) }
finally {
withContext(NonCancellable) {
println("Safe cleanup")
}
}
}.also { delay(50); it.cancel(); it.join() }
}Pulizia di più risorse
Inserisca più operazioni di pulizia in sequenza all'interno di un unico blocco withContext(NonCancellable).
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
try {
delay(1000)
} finally {
withContext(NonCancellable) {
delay(20); println("Step 1: flush cache")
delay(20); println("Step 2: close socket")
delay(20); println("Step 3: log audit")
}
}
}.also { delay(50); it.cancel(); it.join() }
}Pattern try/catch/finally
Combini try-catch per gli errori di business con finally per la pulizia: questo è il pattern strutturato standard.
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
try {
delay(100)
throw RuntimeException("business error")
} catch (e: RuntimeException) {
println("Handling: ${e.message}")
} finally {
withContext(NonCancellable) {
println("Always cleanup")
}
}
}.join()
}Ordine della pulizia
I blocchi finally vengono eseguiti in ordine inverso rispetto all'annidamento. Il blocco try-finally esterno viene eseguito dopo quelli interni, proprio come nel normale codice Java/Kotlin.
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
try {
try {
delay(1000)
} finally { println("Inner cleanup") }
} finally { println("Outer cleanup") }
}.also { delay(50); it.cancel(); it.join() }
}use() per le risorse AutoCloseable
Per le risorse AutoCloseable, utilizzi l'estensione Kotlin use { }, che chiama automaticamente close(), anche in caso di eccezioni o cancellazione.
import kotlinx.coroutines.*
class Connection : AutoCloseable {
init { println("Opened") }
override fun close() { println("Closed") }
suspend fun query(): String { delay(50); return "result" }
}
fun main() = runBlocking {
val result = Connection().use { it.query() }
println(result)
}Registrazione del motivo della cancellazione
Recuperi il messaggio di cancellazione da CancellationException in catch o finally per registrare il motivo per cui una coroutine si è arrestata.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
try {
delay(1000)
} catch (e: CancellationException) {
println("Cancelled: ${e.message}")
throw e
}
}
delay(50)
job.cancel("user navigated away")
job.join()
}Pulizia dello CoroutineScope con invokeOnCompletion
Job.invokeOnCompletion registra un callback che viene eseguito quando il job termina per qualsiasi motivo: è un'alternativa a finally per la pulizia a livello del genitore.
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch {
delay(1000)
}
job.invokeOnCompletion { cause ->
if (cause != null) println("Ended with: ${cause::class.simpleName}")
else println("Completed normally")
}
delay(50)
job.cancel()
job.join()
}Verifica rapida
Qual è lo scopo di withContext(NonCancellable) in un blocco finally?
Riepilogo
finally viene sempre eseguito in caso di cancellazione. Racchiuda le chiamate di sospensione all'interno di finally con withContext(NonCancellable), così potranno completarsi nonostante la cancellazione. Utilizzi use { } per le risorse AutoCloseable.
Domande Frequenti
La lezione «Pulizia con finally e NonCancellable» è gratuita?
Sì — il testo completo di «Pulizia con finally e NonCancellable» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.
Cosa imparerò in «Pulizia con finally e NonCancellable»?
Rilasci le risorse nelle coroutine cancellate usando finally e withContext(NonCancellable). Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Kotlin Academy?
Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Pulizia con finally e NonCancellable»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?
Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Cancellazione cooperativa: isActive ed ensureActive
- withTimeout e withTimeoutOrNull
- Pulizia con finally e NonCancellable
- Propagazione della cancellazione nelle gerarchie di coroutine