0Pricing
Kotlin Academy · 课时

使用 finally 与 NonCancellable 清理资源

在已取消的协程中使用 finally 和 withContext(NonCancellable) 释放资源。

使用 finally 与 NonCancellable 清理资源 是 CoddyKit 上的免费 Kotlin Academy 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Kotlin Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Kotlin Academy 课程共包含 4 节课。

取消与最终清理

协程被取消时，挂起点会抛出 CancellationException。finally 块中的代码始终会运行，但 finally 本身运行在已取消的协程上下文中。

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        try {
            delay(1000)
        } finally {
            println("finally: cleaning up")
        }
    }
    delay(50)
    job.cancel()
    job.join()
}

问题：在最终清理中挂起

如果您尝试在已取消协程的 finally 中调用 delay 或执行其他挂起操作，它会立即抛出异常，因为上下文已经被取消。

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)

请将 finally 中的挂起调用包装在 withContext(NonCancellable) 中，这样即使父级已被取消，它们也会在不可取消的上下文中运行。

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()
}

何时使用 NonCancellable

请在以下场景使用 NonCancellable：关闭数据库连接、刷新日志、发送分析事件，或执行任何无论是否取消都必须完成的异步清理。

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 不是作用域

NonCancellable 是可以传递给 withContext 的 Job。请不要直接将它用作协程作用域；只能在 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() }
}

多个资源的清理

请在单个 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() }
}

尝试—捕获—最终清理模式

将业务错误的尝试—捕获处理与最终清理结合起来，这是标准的结构化模式。

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()
}

清理顺序

最终清理块会按照嵌套顺序的逆序运行。外层的尝试—最终清理会在内层代码之后运行，就像普通的 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() }
}

AutoCloseable 资源的自动关闭

对于 AutoCloseable 资源，请使用 Kotlin 的 use { } 扩展函数；即使发生异常或取消，它也会自动调用 close()。

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)
}

记录取消原因

请在 catch 或 finally 中从 CancellationException 获取取消消息，以记录协程停止的原因。

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()
}

使用 invokeOnCompletion 清理 CoroutineScope

Job.invokeOnCompletion 会注册一个回调，在作业因任何原因结束时运行——它可以替代 finally，用于执行父级清理。

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()
}

快速检查

在 finally 块中使用 withContext(NonCancellable) 的目的是什么？

回顾

取消时 finally 始终会运行。请将 finally 中的挂起调用包装在 withContext(NonCancellable) 内，使它们即使在取消后也能完成。对于 AutoCloseable 资源，请使用 use { }。

常见问题解答

「使用 finally 与 NonCancellable 清理资源」课时是免费的吗？

是的 — 「使用 finally 与 NonCancellable 清理资源」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Kotlin Academy 课程的其余内容，请升级到 CoddyKit PRO。 Kotlin Academy 课程共包含 4 节课。

「使用 finally 与 NonCancellable 清理资源」这节课中我会学到什么？

在已取消的协程中使用 finally 和 withContext(NonCancellable) 释放资源。 你通过在浏览器中直接运行的动手代码来练习 Kotlin Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Kotlin Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Kotlin Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

「使用 finally 与 NonCancellable 清理资源」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Kotlin Academy 课中编写并运行代码吗？

能。每节 Kotlin Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 协作式取消：isActive 与 ensureActive
  2. withTimeout 与 withTimeoutOrNull
  3. 使用 finally 与 NonCancellable 清理资源
  4. 协程层次结构中的取消传播
← 返回 Kotlin Academy