理解 Kotlin 中的协程生命周期
Kotlin 的协程提供了一种强大的方式来管理并发和异步编程。要有效地使用它们，理解协程的生命周期至关重要。本文将探讨协程生命周期，重点介绍协程的 Job 状态、状态之间的转换，并通过实际示例说明每个状态的效果，包括启动嵌套协程等。
什么是协程？
协程是轻量级的线程，可以在不阻塞主线程的情况下执行异步任务。它们提供了一种编写非阻塞代码的方式，使代码易于阅读和维护。在 Kotlin 中，协程围绕 Job 的概念进行结构化。
什么是 Job？
Job 是协程的句柄。它表示其生命周期，并允许你管理其执行，包括启动、取消和检查其状态。Job 提供了协程在其生命周期中可能处于的几种状态。
协程 Job 的生命周期状态
协程的 Job 生命周期包括以下状态：
1. 新建（New）：协程已创建但尚未启动。
2. 活动（Active）：协程当前正在运行。
3. 完成中（Completing）：协程正在完成其工作。
4. 已完成（Completed）：协程已成功完成其执行。
5. 取消中（Cancelling）：协程正在被取消。
6. 已取消（Cancelled）：协程已被取消且不会完成。
状态转换示意图
等待子协程 +-----+ start +--------+ complete +-------------+ finish +-----------+ | 新建 | -----> | Active | --------> | Completing | -------> | 已完成 | +-----+ +--------+ +-------------+ +-----------+ | 取消 / 失败 | | +----------------+ | | V V +------------+ 完成 +-----------+ | 取消中 | --------------------------------> | 已取消 | +------------+ +-----------+状态转换解析
1. 新建（New）
协程在新建状态开始其生命周期。这时，协程已创建但尚未运行。
fun main() {
val job = GlobalScope.launch {
println("协程正在启动...")
}
println("Job 状态（新建）: ${job.isActive}")
}
// 输出：
// Job 状态（新建）: true2. 活动（Active）
当协程开始执行时，它转换到活动状态。在此状态下，协程可以执行其指定的任务。
fun main() = runBlocking {
val job = launch {
println("协程现在处于活动状态！")
delay(1000) // 模拟工作
}
println("Job 状态（活动）: ${job.isActive}")
job.join()
}
// 输出：
// 协程现在处于活动状态！
// Job 状态（活动）: true3. 完成中（Completing）
当协程完成其任务时，它进入完成中状态。此状态指示协程即将完成其执行。
fun main() = runBlocking {
val job = launch {
println("协程正在工作...")
delay(1000) // 模拟工作
println("协程即将完成...")
}
// 注册回调
job.invokeOnCompletion {
println("Job 完成: ${if (it == null) "成功" else "失败或取消"}")
}
job.join()
}
// 输出：
// 协程正在工作...
// 协程即将完成...
// Job 完成: 成功4. 已完成（Completed）
一旦协程完成其执行，它将转换到已完成状态。协程已成功执行其任务。
fun main() = runBlocking {
val job = launch {
println("任务开始...")
delay(1000) // 模拟工作
}
job.join()
println("Job 状态（已完成）: ${job.isCompleted}")
}
// 输出：
// 任务开始...
// Job 状态（已完成）: true5. 取消中（Cancelling）
如果协程被取消，它将进入取消中状态。在此状态下，协程正在被停止，任何正在进行的工作应被清理。
fun main() = runBlocking {
val job = launch {
try {
repeat(5) { i ->
println("协程正在工作... $i")
delay(500) // 模拟工作
}
} finally {
println("协程已取消")
}
}
// 注册回调
job.invokeOnCompletion { cause ->
println("Job 完成: ${if (cause == null) "成功" else "失败或取消: ${cause.message}"}")
}
delay(1000) // 让协程运行一会儿
println("正在取消协程...")
job.cancel() // 取消协程
job.join() // 等待协程完成以确保看到 invokeOnCompletion 输出
}
// 输出：
// 协程正在工作... 0
// 协程正在工作... 1
// 正在取消协程...
// 协程已取消
// Job 完成: 失败或取消: CancellationException6. 已取消（Cancelled）
取消完成后，协程达到已取消状态。此时，协程已停止其执行且不会完成其任务。
fun main() = runBlocking {
val job = launch {
println("启动协程...")
delay(2000) // 模拟一个长任务
}
// 注册回调
job.invokeOnCompletion {
println("Job 完成: ${if (it == null) "成功" else "失败或取消"}")
}
delay(500) // 让它运行一会儿
job.cancel() // 取消协程
println("Job 状态（已取消）: ${job.isCancelled}") // 应为 true
job.join() // 等待协程完成以确保看到 invokeOnCompletion 输出
}
// 输出：
// 启动协程...
// Job 状态（已取消）: true
// Job 完成: 失败或取消: CancellationException协程作用域
协程作用域定义了可以启动协程的作用范围。它有助于管理协程的生命周期并强制进行结构化并发。当一个作用域被取消时，在该作用域内启动的所有协程也会被取消。最常见的协程作用域包括：
• GlobalScope：启动应用程序生命周期内存活的协程。
• CoroutineScope：与特定组件（如 Android 中的 activity 或 fragment）绑定的用户定义作用域。
调度器Dispatchers
调度器定义了协程将运行的线程或线程池。常见的调度器包括：
• Dispatchers.Main：用于 UI 操作，在主线程上运行。
• Dispatchers.IO：优化用于 I/O 操作，比如网络调用或读取文件。
• Dispatchers.Default：用于 CPU 密集型任务。
调度器的选择影响协程的执行方式及其与应用程序其余部分的交互，影响其生命周期和性能。
处理协程中的故障和异常
管理故障和异常对于构建可靠的应用程序至关重要。协程提供了结构化的异常处理机制，用于处理异步操作中可能出现的异常。以下是管理协程异常的重要概念和实践：
1. 异常传播
默认情况下，协程中抛出的异常会传播到父协程。如果父协程捕获了异常，则子协程将被取消，异常将向上传递。
fun main() = runBlocking {
val parentJob = launch {
try {
launch {
throw Exception("子协程失败")
}
} catch (e: Exception) {
println("在父协程中捕获异常: ${e.message}")
}
}
parentJob.join()
}
// 输出：
// 在父协程中捕获异常: 子协程失败2. 使用 supervisorScope
使用 supervisorScope 时，可以独立处理子协程的故障。如果一个子协程失败，它不会取消其他子协程或父协程。
fun main() = runBlocking {
supervisorScope {
val child1 = launch {
println("子协程1启动")
delay(1000)
println("子协程1完成")
}
val child2 = launch {
println("子协程2启动")
throw Exception("子协程2失败")
}
val child3 = launch {
println("子协程3启动")
delay(1000)
println("子协程3完成")
}
}
println("父协程继续运行...")
}
// 输出：
// 子协程1启动
// 子协程2启动
// 子协程3启动
// 子协程1完成
// 子协程3完成
// 父协程继续运行...3. CoroutineExceptionHandler
使用 CoroutineExceptionHandler 处理未捕获的异常。此处理器可以作为协程上下文的一部分传递，以管理协程内未捕获的异常。
fun main() = runBlocking {
val exceptionHandler = CoroutineExceptionHandler { _, exception ->
println("捕获异常: ${exception.message}")
}
val job = launch(exceptionHandler) {
throw Exception("协程失败")
}
job.join()
}
// 输出：
// 捕获异常: 协程失败4. 清理资源
当协程失败或被取消时，确保清理任何资源（如关闭文件或释放锁）。使用 finally 块确保无论是否发生异常，清理代码都能运行。
fun main() = runBlocking {
val job = launch {
try {
println("协程启动中...")
delay(1000)
throw Exception("出现问题")
} finally {
println("清理资源...")
}
}
job.join() // 等待协程完成
}
// 输出：
// 协程启动中...
// 清理资源...启动嵌套协程
嵌套协程可能会影响父协程的生命周期和行为，特别是在取消和完成方面。当在另一个协程内启动协程（嵌套协程）时，它继承其父协程的生命周期。这意味着如果父协程被取消，嵌套协程也会被取消，除非它在不同的上下文或作用域中启动。
嵌套协程的示例
fun main() = runBlocking {
val parentJob = launch {
println("父协程启动于 ${Thread.currentThread().name}")
val childJob = launch(Dispatchers.Default) {
println("子协程启动于 ${Thread.currentThread().name}")
delay(2000) // 模拟工作
println("子协程完成")
}
delay(1000) // 让子协程运行一会儿
println("正在取消父协程...")
cancel() // 取消父协程
}
// 注册回调
parentJob.invokeOnCompletion { cause ->
println("父Job完成: ${if (cause == null) "成功" else "失败或取消: ${cause.message}"}")
}
parentJob.join() // 等待父协程完成
}
// 输出：
// 父协程启动于 main
// 子协程启动于 DefaultDispatcher-worker-1
// 正在取消父协程...
// 父Job完成: 失败或取消: CancellationException在这个示例中，当父协程被取消时，子协程也被取消，显示了嵌套协程的继承生命周期行为。
取消后 Job 是否进入已完成状态？
Job 在被取消后会转到已完成状态。以下是如何验证这一点：
fun main() = runBlocking {
val job = launch {
println("协程正在工作...")
delay(1000) // 模拟工作
}
job.cancel()
job.join()
println("Job 完成状态: ${job.isCompleted}")
}
// 输出：
// 协程正在工作...
// Job 完成状态: true最佳实践和建议
1. 使用结构化并发
始终在特定作用域内启动协程，确保它们与创建它们的组件生命周期相关联。这可以防止内存泄漏并确保正确的取消。
2. 首选 CoroutineScope 而不是 GlobalScope
使用 CoroutineScope 管理与特定组件（例如 Activity，Fragment）相关联的协程，而不是 GlobalScope ，后者可能导致无法控制的协程生命周期。
3. 处理异常
在协程内部实现异常处理，使用 try-catch 块或协程异常处理器有效地捕获和处理异常。
4. 必要时使用 supervisorScope
处理嵌套协程时，考虑使用 supervisorScope，以防止一个子协程的故障影响其他子协程。
5. 监控协程状态
利用 invokeOnCompletion 并检查 Job 的状态，以管理生命周期并处理任何必要的清理或状态检查。
6. 避免阻塞调用
确保不要使用长时间运行的任务阻塞协程调度器。如果需要，使用 withContext 切换上下文。
结论
理解协程的生命周期，包括嵌套协程的影响和 supervisorScope 的角色，是编写健壮异步代码的关键。通过管理父子关系并有效处理取消和失败，可以创建高效可靠的应用程序。
无论使用 invokeOnCompletion 进行清理，管理嵌套协程，还是利用结构化并发，Kotlin 的协程都提供了强大的工具，使你能够轻松处理并发。