Learn Kotlin Coroutines: An Introduction – wiki基地

---

深入浅出 Kotlin Coroutines：现代异步编程利器入门指南

在现代软件开发中，处理并发和异步任务是一个绕不开的话题。无论是需要响应迅速的移动应用界面，还是需要同时处理大量请求的后端服务，高效地管理耗时操作都是关键。传统的线程和回调方式在应对复杂场景时常常力不从心，导致代码难以维护、容易出错。Kotlin 协程（Coroutines）应运而生，提供了一种更简洁、更强大的异步编程解决方案。

本文将带您深入了解 Kotlin Coroutines 的核心概念、工作原理及其基本用法，帮助您迈出协程学习的第一步。

为什么我们需要协程？传统方法的困境

在深入了解协程之前，我们先回顾一下传统的异步编程方式及其面临的挑战：

1. 回调（Callbacks）： 这是最常见的一种异步处理方式。例如，网络请求完成后调用一个回调函数。当存在多个相互依赖的异步操作时，就会出现臭名昭著的“回调地狱”（Callback Hell），代码嵌套层层，难以阅读和维护，错误处理和流程控制也变得复杂。

2. 线程（Threads）： 直接使用线程是另一种方式。可以将耗时任务放在单独的线程中执行，避免阻塞主线程（如 UI 线程）。然而，线程是操作系统级别的资源，创建和管理线程的开销较大。大量的线程会导致显著的内存消耗和上下文切换开销，降低系统性能。同时，线程间的通信和同步（如锁、信号量）容易引发死锁、竞态条件等问题，增加开发和调试难度。

3. Futures/Promises： 这些抽象提供了更结构化的异步编程方式，可以链式调用异步操作。但它们的组合性仍然不如同步代码直观，错误处理有时也不够优雅。

这些传统方法都有其局限性，尤其是在需要处理复杂的异步流程时。我们渴望一种能够让我们用“同步”的方式编写“异步”代码的解决方案，让逻辑更加线性、易于理解。Kotlin Coroutines 正是为解决这一问题而设计的。

什么是 Kotlin Coroutines？核心概念解析

Kotlin Coroutines 可以被理解为轻量级的线程。它们不是操作系统提供的原生线程，而是在用户空间实现的。与线程不同，协程的切换是由开发者（或协程库）通过特定的语言特性协作完成的，而不是由操作系统内核抢占式调度。这带来了巨大的优势：

• 轻量级： 创建一个协程的开销远小于创建一个线程。你可以在单个线程中运行成千上万个协程。
• 非阻塞： 协程通过“挂起”（Suspension）而非“阻塞”来处理等待。当一个协程遇到一个耗时的异步操作（如网络请求），它不会阻塞它所在的线程，而是将自己挂起，释放线程去执行其他任务。当异步操作完成后，协程会在同一个线程（或者其他可用线程）上从挂起的地方恢复执行。
• 结构化并发（Structured Concurrency）： 协程库提倡使用结构化并发原则，使得并发代码的生命周期管理更加容易和安全，例如，当一个父协程取消时，其所有子协程也会被取消，这有助于防止资源泄露。
• 编写同步代码的方式： 协程允许你使用看似同步的顺序代码来表达复杂的异步逻辑，大大提高了代码的可读性和可维护性。

要理解 Kotlin Coroutines，需要掌握几个核心概念：

1. suspend 关键字：
   suspend 是协程最核心的关键字。它只能用于函数声明前，表示这个函数是一个“挂起函数”。挂起函数只能在其他挂起函数中调用，或者在协程中调用。
   当协程执行到一个挂起函数时，它可能会暂停执行，直到挂起函数完成并返回结果。重要的是，这个暂停是非阻塞的。线程不会等待，而是可以去做其他事情。
   例如：
   “`kotlin
   suspend fun fetchData(): String {
   // 模拟一个耗时的网络请求或其他异步操作
   delay(1000) // 这是一个挂起函数，会挂起当前协程1秒，但不会阻塞线程
   return “Data fetched after 1 second”
   }

   // 这是一个常规函数，不能直接调用 suspend 函数
   fun processData() {
   // 错误！不能在这里直接调用 fetchData()
   }

   // 必须在协程中调用 suspend 函数
   suspend fun performTask() {
   val data = fetchData() // 在协程中调用挂起函数
   println(data)
   }
   ``delay()` 是 Kotlin Coroutines 库提供的一个简单挂起函数，用于演示暂停。它不会阻塞线程，而是让出执行权。

2. 协程作用域（Coroutine Scope）：
   协程必须运行在一个协程作用域（CoroutineScope）内。协程作用域负责管理其内部启动的协程的生命周期。当一个作用域被取消时，其内部的所有协程也会被取消。这实现了结构化并发。
   常见的协程作用域包括：

   • GlobalScope：这是一个全局作用域，与应用的整个生命周期绑定。不推荐在实际应用中使用 GlobalScope，因为它启动的协程很难追踪和取消，容易导致资源泄露或意外行为。
   • 为特定组件（如 Android 中的 Activity/ViewModel，服务器中的请求处理）创建的自定义作用域：例如，Android 官方库提供了 lifecycleScope, viewModelScope 等，它们与对应的组件生命周期绑定。
   • 使用 coroutineScope 或 supervisorScope 函数创建的局部作用域。

3. Job：
   每个启动的协程都与一个 Job 实例关联。Job 代表了一个协程的生命周期。你可以使用 Job 来管理协程，例如：

   • job.join()：等待协程完成。这是一个挂起函数，会挂起当前协程直到目标协程完成。
   • job.cancel()：取消协程。这是一个非阻塞操作，向协程发送取消信号。
   • 检查协程的状态（如 isActive, isCompleted, isCancelled）。
     Job 也是协程上下文（Coroutine Context）的一个元素。

4. 调度器（Dispatcher）：
   调度器决定了协程在哪个线程或哪些线程上执行。Kotlin Coroutines 提供了几种标准的调度器：

   • Dispatchers.Main：主线程调度器。通常用于更新 UI 或执行与主线程相关的操作。在 Android 中通常指 UI 线程。
   • Dispatchers.IO：用于执行阻塞 I/O 操作，如网络请求、文件读写、数据库访问等。它使用一个共享的按需创建的线程池。
   • Dispatchers.Default：默认调度器，用于执行 CPU 密集型任务。它使用的线程数量通常等于 CPU 核数。
   • Dispatchers.Unconfined：非受限调度器。协程在调用它的当前线程上启动，但一旦遇到第一个挂起函数，它会在恢复后切换到挂起函数所在的线程（取决于该挂起函数的实现）。不推荐在大多数场景下使用 Unconfined，除非你清楚它的行为。

   你可以通过 withContext(dispatcher) 函数轻松地在不同的调度器之间切换，同时保持代码的顺序性。例如：
   “`kotlin
   suspend fun fetchDataFromNetwork(): String {
   // 切换到 IO 调度器执行网络请求
   return withContext(Dispatchers.IO) {
   // 模拟网络请求
   delay(2000)
   “Network Data”
   }
   }

   suspend fun updateUI(data: String) {
   // 切换回 Main 调度器更新 UI
   withContext(Dispatchers.Main) {
   println(“Updating UI with: $data”)
   }
   }

   fun main() = runBlocking { // runBlocking 是一个协程构建器，用于桥接普通阻塞代码和协程
   val data = fetchDataFromNetwork()
   updateUI(data)
   }
   “`

5. 协程上下文（Coroutine Context）：
   协程上下文是一组元素的集合，这些元素定义了协程的行为。它包括 Job、Dispatcher、CoroutineName（协程名称，用于调试）以及其他可能的元素（如异常处理器 CoroutineExceptionHandler）。
   当启动一个协程时，可以为其指定一个上下文。如果未指定，它会继承父协程的上下文。withContext 函数不仅可以切换调度器，还可以修改协程的上下文。

协程构建器（Coroutine Builders）

要启动一个协程，我们需要使用协程构建器。Kotlin Coroutines 提供了几个常用的构建器：

1. launch：
   launch 是一个用于启动“不关心结果”或“副作用”任务的构建器。它返回一个 Job，你可以用它来取消或等待协程完成，但它本身不返回计算结果。launch 通常用于启动一个独立的后台任务，例如在后台更新数据，而不需要等待更新完成才能继续主流程。
   kotlin
fun main() = runBlocking {
val job = launch {
println("Coroutine started: ${coroutineContext[Job]}")
delay(1000)
println("Coroutine finished")
}
println("Waiting for coroutine...")
job.join() // 等待协程完成
println("Main finished")
}

2. async：
   async 是一个用于启动会返回结果的任务的构建器。它返回一个 Deferred<T>，这是一个非阻塞的、可取消的 Future。你可以使用 await() 方法来获取 async 协程的计算结果。await() 是一个挂起函数，它会挂起当前协程直到 async 任务完成并返回结果。async 通常用于并行执行多个任务，然后等待它们的结果。
   “`kotlin
   fun main() = runBlocking {
   val deferred1 = async {
   delay(1000)
   println(“Task 1 finished”)
   “Result 1”
   }
   val deferred2 = async {
   delay(2000)
   println(“Task 2 finished”)
   “Result 2”
   }

   println("Waiting for results...")
   // await() 是挂起函数，会等待对应的 async 任务完成
   val result1 = deferred1.await()
   val result2 = deferred2.await()
   
   println("Combined results: $result1, $result2")
   

   }
   ``
使用async和await可以很容易地实现并行计算。如果上面的例子改成顺序调用两个delay函数，总耗时将是 3 秒。但使用async` 并行执行，总耗时大约是 2 秒（取最长任务的耗时）。

3. runBlocking：
   runBlocking 是一个特殊的协程构建器，主要用于连接普通的阻塞代码和协程世界。它会阻塞当前线程，直到其内部的协程执行完成。runBlocking 主要用于 main 函数、单元测试或需要在阻塞环境中调用挂起函数时。切勿在生产环境的非测试/非 main 函数中使用 runBlocking，因为它会阻塞线程，这与协程非阻塞的初衷相悖。
   kotlin
fun main() = runBlocking { // 阻塞主线程直到内部协程完成
println("Start")
delay(1000) // 挂起协程，但不阻塞 runBlocking 所在的线程 (虽然这里就是主线程，但它能处理其他协程)
println("End")
}

结构化并发实践

结构化并发是协程设计中的一个重要理念，它强调协程之间的父子关系以及生命周期的联动。主要体现在以下几个方面：

• 父子关系： 在一个 CoroutineScope 中启动的协程（使用 launch 或 async）会自动成为该作用域的子协程。在一个父协程中启动的协程会成为其子协程。
• 生命周期联动：
  • 如果父协程被取消，其所有子协程也会递归地被取消。
  • 如果子协程因为异常而失败（对于 launch 启动的子协程），默认情况下会传播给父协程，导致父协程也被取消，并继续向上层传播异常。
  • 父协程会等待所有子协程完成（除非被取消）。

这种父子结构使得协程的取消和错误处理更加可预测和易于管理，避免了协程“泄露”（即协程在不该运行的时候还在运行）的问题。

使用 coroutineScope 和 supervisorScope：

• coroutineScope：这是一个挂起函数，它会创建一个新的协程作用域，并等待其内部启动的所有协程完成。如果内部的任何子协程失败并抛出异常，该异常会立即传播到 coroutineScope 的调用者，并导致 coroutineScope 以及所有其他子协程被取消。它强制执行了严格的结构化并发，任何子任务的失败都会导致父任务失败。
  “`kotlin
  suspend fun performTwoTasksSequentiallyOrCancel() = coroutineScope {
  launch {
  delay(500)
  println(“Task 1 done”)
  }
  launch {
  delay(1000)
  // 如果这里抛异常，会导致上面 Task 1 也被取消，整个 coroutineScope 结束并抛异常
  // throw IllegalStateException(“Task 2 failed”)
  println(“Task 2 done”)
  }
  println(“coroutineScope waiting…”)
  }

  fun main() = runBlocking {
  try {
  performTwoTasksSequentiallyOrCancel()
  } catch (e: Exception) {
  println(“CoroutineScope failed: ${e.message}”)
  }
  println(“Main continues”)
  }
  “`

• supervisorScope：这是一个挂起函数，类似于 coroutineScope，但它采用了不同的错误处理策略。如果 supervisorScope 的一个子协程失败，该失败不会传播给父协程或影响其兄弟协程。只有该子协程自己被取消。异常需要由子协程自己处理（例如通过 CoroutineExceptionHandler 或 try-catch）。supervisorScope 常用于需要在某些子任务失败时仍让其他子任务继续执行的场景，例如 UI 元素的并行加载。
  “`kotlin
  suspend fun performTasksIndependently() = supervisorScope {
  val job1 = launch {
  delay(500)
  println(“Task 1 done in supervisorScope”)
  }
  val job2 = launch {
  delay(1000)
  // 如果这里抛异常，只会影响 Task 2，Task 1 会继续执行
  // throw IllegalStateException(“Task 2 failed in supervisorScope”)
  println(“Task 2 done in supervisorScope”)
  }

  // SupervisorJob 或 supervisorScope 的一个子协程失败，异常不会自动传播给父 Job
  // 所以需要在子协程内部处理异常，或者使用 CoroutineExceptionHandler
  job2.invokeOnCompletion { cause ->
       if (cause != null) {
           println("Task 2 failed with $cause")
       }
  }
  
  println("supervisorScope waiting...")
  

  }

  fun main() = runBlocking {
  try {
  performTasksIndependently()
  } catch (e: Exception) {
  println(“SupervisorScope exception caught at call site (won’t happen from child): $e”)
  }
  println(“Main continues after supervisorScope”)
  }
  ``
请注意，即使子协程抛出异常，supervisorScope本身通常不会因为子协程的失败而抛出异常到其调用者。你需要通过其他方式处理子协程的失败，例如为子协程添加CoroutineExceptionHandler`。

协程的取消（Cancellation）

协程的取消是协作式的。这意味着协程并不会在收到取消信号后立即强制停止，而是需要在挂起函数中检查取消状态，并主动响应取消。

大多数 Kotlin Coroutines 库提供的挂起函数（如 delay, withContext, await, IO 操作等）都是可取消的。当它们所属的协程被取消时，这些函数会立即抛出 CancellationException。

对于你自己编写的挂起函数，如果其中有长时间运行的计算或循环，你需要定期检查协程的取消状态，并在被取消时停止工作或抛出异常：

• 检查 isActive 属性： coroutineContext.isActive 可以检查协程是否仍然处于活动状态。
• 使用 ensureActive() 函数： 这是一个更方便的方法，如果协程已经被取消，它会立即抛出 CancellationException。
• 使用 yield() 函数： yield() 会让出当前线程的执行权，允许其他协程运行。同时，yield() 也会检查协程的取消状态，如果已取消则抛出 CancellationException。

“`kotlin
suspend fun doingSomeHeavyWork() = coroutineScope {
repeat(1000) { i ->
// 检查是否已取消
ensureActive() // 或者 if (!isActive) return@coroutineScope 或 throw CancellationException()

    println("Working... $i")
    delay(10) // delay 也是一个检查取消的挂起函数
}

}

fun main() = runBlocking {
val job = launch {
doingSomeHeavyWork()
}
delay(100) // 等待一小会儿
println(“Cancelling job…”)
job.cancelAndJoin() // 取消并等待协程完成清理
println(“Job cancelled and joined”)
}
``
当调用job.cancel()时，协程会收到取消信号，delay(10)或ensureActive()会检测到这个信号，并抛出CancellationException`，从而终止协程的执行。

协程的异常处理（Exception Handling）

协程中的异常处理与普通的同步代码有所不同，特别是异常的传播行为。

• launch 启动的协程：

  • 如果子协程（由 launch 启动）抛出异常，该异常会传播到父协程。
  • 如果根协程（直接在 CoroutineScope 中由 launch 启动，没有父协程）抛出异常，该异常会在抛出的线程上 uncaught，通常会导致应用崩溃（除非设置了全局的 UncaughtExceptionHandler 或使用 CoroutineExceptionHandler）。

• async 启动的协程：

  • async 捕获其内部的异常，并将其存储在返回的 Deferred 对象中。
  • 异常只会在调用 await() 时重新抛出。
  • 如果 async 的子协程（由 async 启动）失败，失败会传播给父协程，导致父协程取消（除非父协程是一个 SupervisorJob 或在 supervisorScope 中）。

• runBlocking：

  • runBlocking 会等待其内部协程完成。如果内部协程或其子协程抛出异常，runBlocking 会捕获该异常并重新抛出。

• CoroutineExceptionHandler：
  CoroutineExceptionHandler 是一个可选的上下文元素，可以附加到协程上下文。它只对根协程（即在没有父协程的情况下由 launch 启动的协程）或在 supervisorScope 中启动的协程起作用。
  “`kotlin
  val handler = CoroutineExceptionHandler { _, exception ->
  println(“Caught exception: $exception”)
  }

  fun main() = runBlocking {
  val job = GlobalScope.launch(handler) { // 附加到根协程 (GlobalScope 的子协程是根协程)
  throw IllegalStateException(“Oops!”)
  }
  job.join()

  val job2 = launch { // 这是 runBlocking 的子协程
       launch(handler) { // 这个 handler 不会起作用，异常会传播给 job2
           throw IllegalArgumentException("Another Oops!")
       }
  }
  // job2 失败会导致 runBlocking 抛出异常
  // runBlocking { job2.join() } // 如果去掉 try-catch 会在这里崩溃
   try {
       job2.join()
   } catch (e: Exception) {
       println("Caught exception from job2's child: $e")
   }
  
  supervisorScope {
      launch(handler) { // 在 supervisorScope 中启动的子协程，handler 会起作用
          throw IndexOutOfBoundsException("Yet another Oops!")
      }
  }
  

  }
  ``
总结异常处理策略：
* 对于async启动的任务，使用try-catch包裹await()调用来处理异常。
* 对于launch启动的任务：
* 如果是在普通作用域中启动的（非supervisorScope），异常会传播。可以在父协程中捕获（如果父协程也是launch或runBlocking启动的，可以在其外部try-catch）。更推荐的是使用CoroutineExceptionHandler附加到根协程。
* 如果是在supervisorScope或带有SupervisorJob的作用域中启动的，异常不会传播给父协程。需要在子协程内部使用try-catch或附加CoroutineExceptionHandler` 到该子协程。

常用场景示例

1. Android 开发：

   • 在 viewModelScope 或 lifecycleScope 中启动协程执行网络请求或数据库操作 (Dispatchers.IO)。
   • 在协程中执行完耗时任务后，切换回 Dispatchers.Main 更新 UI。
   • 利用结构化并发，当 ViewModel 或 Activity 销毁时，自动取消关联的协程。
     kotlin
class MyViewModel: ViewModel() {
fun loadData() {
viewModelScope.launch { // viewModelScope 与 ViewModel 生命周期绑定
try {
val data = withContext(Dispatchers.IO) { // 切换到 IO 线程执行耗时操作
// 模拟网络请求
delay(2000)
"Loaded Data"
}
// 自动回到主线程 (viewModelScope.launch 默认在 Main 线程)
println("Data loaded: $data")
// 更新 LiveData 或 StateFlow 以更新 UI
} catch (e: Exception) {
println("Error loading data: ${e.message}")
// 处理错误，例如显示错误信息到 UI
}
}
}
}

2. 后端服务：

   • 使用协程处理并发请求，每个请求可以在一个独立的协程中处理。
   • 在处理请求时，执行非阻塞的数据库查询或调用其他服务。
   • 利用协程的轻量级，可以用更少的线程处理更多的并发连接。
     kotlin
// 伪代码，使用 Ktor 这样的协程友好框架
// fun Application.module() {
// routing {
// get("/data") {
// val result = async(Dispatchers.IO) {
// // 异步执行数据库查询
// delay(1000)
// "Data from DB"
// }.await() // 等待结果
// call.respondText(result)
// }
// }
// }

协程 vs 线程：深入理解非阻塞

理解协程的非阻塞特性是掌握协程的关键。

想象一个餐厅服务员（线程）。如果一个顾客（任务）点了一份需要长时间烹饪的菜肴（阻塞操作），传统的服务员会一直站在厨房门口等这道菜做好（线程被阻塞）。这段时间里，即使有其他顾客招手，他也无法服务。

而协程就像一个更聪明、更灵活的服务员。当顾客点了那道耗时的菜，服务员（协程）会把订单交给厨师（异步操作），然后不会傻等。他会去服务其他顾客，收钱、点餐、送水等等。当厨师喊“那道菜好了”，这个服务员（协程）就会从他当前服务的地方暂停，去厨房拿菜，然后回到原来那个顾客那里恢复服务，把菜端上去。

这里的关键是：
* 线程是资源： 线程是有限的、昂贵的，被阻塞会浪费资源。
* 协程是任务： 协程是轻量的、廉价的，可以轻易创建成千上万个。
* 阻塞 vs 挂起： 线程阻塞意味着它停止一切工作，等待某个事件。协程挂起意味着它暂停当前任务，释放它所在的线程去执行其他协程。当等待的事件发生后，协程会被安排在某个可用的线程上恢复执行。

因此，协程特别适合处理大量的并发 I/O 密集型任务，因为这些任务大部分时间都在等待（网络、磁盘）。协程可以在等待时释放线程，提高线程的利用率。对于 CPU 密集型任务，协程仍然需要线程来执行计算，但它们提供了一种更方便的方式来组织并发代码（例如使用 Dispatchers.Default 并在计算过程中定期 yield()）。

总结与下一步

本文详细介绍了 Kotlin Coroutines 的基本概念，包括为什么需要它、suspend 关键字、Coroutine Scope、Job、Dispatcher、Coroutine Context、常用的协程构建器 (launch, async, runBlocking)，以及结构化并发、取消和异常处理的基础知识。

通过学习这些内容，您应该已经对 Kotlin Coroutines 有了一个初步且全面的认识。它们提供了一种强大且直观的方式来处理异步和并发任务，让您的代码更加清晰、简洁和高效。

但协程的世界远不止于此。为了更深入地掌握协程，您可以继续学习：

• Flow： 用于处理异步数据流，是协程在响应式编程领域的应用。
• Channels： 用于协程之间的通信。
• 更高级的协程构建器和作用域函数。
• 协程的内部实现原理。
• 在不同平台（Android、JVM 后端、Native、JS）上协程的具体应用和最佳实践。

实践是最好的老师。开始在您的项目中使用 Kotlin Coroutines 吧！从简单的异步任务开始，逐步尝试处理更复杂的并发场景。随着您的经验增长，您会越来越感受到协程带来的便利和强大。

希望本文能为您开启 Kotlin Coroutines 的学习之旅提供坚实的基础！

---