Kotlin Coroutines: 异步编程深度解析 – wiki基地

作者： /

Kotlin Coroutines: 异步编程深度解析

在现代应用程序开发中，异步编程是不可或缺的一部分。无论是处理网络请求、数据库操作还是长时间运行的计算，高效地管理并发和响应性都是关键。在 Java 领域，传统的线程和回调机制在复杂场景下常常导致代码难以理解、维护和调试，即所谓的“回调地狱”或“线程地狱”。Kotlin Coroutines（协程）的出现，为 Kotlin 乃至整个 JVM 生态系统带来了优雅且强大的异步编程解决方案。

1. 什么是协程？

协程可以被理解为“轻量级的线程”。与操作系统线程不同，协程的调度和管理由应用程序（或协程库）在用户空间完成，而不是由操作系统内核。这使得协程的创建和切换开销远低于线程，单个线程可以运行成千上万个协程，从而显著提高了并发性能和资源利用率。

协程的核心思想是“结构化并发”。它允许开发者以同步编程的直观方式编写异步代码，避免了复杂的嵌套回调，使代码更具可读性和可维护性。

2. 协程的基本概念

2.1 挂起函数 (Suspend Function)

挂起函数是协程的基石。在 Kotlin 中，使用 suspend 关键字修饰的函数就是挂起函数。当一个挂起函数被调用时，它可以在不阻塞当前线程的情况下“暂停”执行，并在稍后某个时刻“恢复”执行。

kotlin
suspend fun fetchData(): String {
delay(1000) // 模拟网络请求或长时间操作，不会阻塞线程
return "Data from network"
}

  • 非阻塞： delay() 函数是一个特殊的挂起函数，它会挂起当前协程的执行，而不是阻塞底层线程。当延迟结束后，协程会在同一个或不同的线程上恢复执行。
  • 只能在协程或其他挂起函数中调用： 挂起函数只能在其它的挂起函数中或在协程构建器（如 launch, async）中调用。

2.2 协程构建器 (Coroutine Builders)

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

  • launch: 启动一个新协程，不返回结果。它通常用于“发送即忘记”的操作，例如更新 UI 或执行后台任务。

    kotlin
    fun main() = runBlocking {
    launch { // 启动一个新协程
    delay(1000)
    println("World!")
    }
    println("Hello,")
    }
    // 输出：
    // Hello,
    // (等待1秒)
    // World!

  • async: 启动一个新协程，并返回一个 Deferred 对象，Deferred 是一个轻量级的 Future，它持有协程的计算结果。你可以通过调用 await() 方法获取结果。

    “`kotlin
    suspend fun calculateSum(): Int {
    val deferred1 = async {
    delay(1000)
    10
    }
    val deferred2 = async {
    delay(500)
    20
    }
    return deferred1.await() + deferred2.await() // 等待两个结果并求和
    }

    fun main() = runBlocking {
    val sum = calculateSum()
    println(“Sum: $sum”) // 输出 Sum: 30
    }
    “`

  • runBlocking: 这是一个特殊的协程构建器，它会阻塞当前线程直到其内部的所有协程执行完成。它主要用于连接非协程代码（例如 main 函数或单元测试）和协程代码。在实际应用程序中应谨慎使用，因为它会阻塞线程。

2.3 协程作用域 (Coroutine Scope) 和协程上下文 (Coroutine Context)

  • 协程作用域 (CoroutineScope): 它定义了协程的生命周期和结构化并发。在某个 CoroutineScope 中启动的协程，其生命周期会绑定到该作用域。当作用域被取消时，所有在其内部启动的子协程也会被取消，这有助于防止资源泄露和未完成任务。

    • GlobalScope: 全局作用域，协程的生命周期与整个应用程序相同。不建议在业务代码中直接使用，因为它不遵循结构化并发原则，难以管理。
    • viewModelScope (Android): 专门为 Android ViewModel 设计的作用域，当 ViewModel 被清除时自动取消所有子协程。
    • 自定义作用域：你可以通过 CoroutineScope() 构造函数创建自己的作用域，并手动管理其生命周期。

  • 协程上下文 (CoroutineContext): 它是一组元素的集合，这些元素定义了协程的行为。主要的上下文元素包括：

    • 调度器 (CoroutineDispatcher): 决定协程在哪里（哪个线程或线程池）执行。
      • Dispatchers.Default: 适用于 CPU 密集型任务，使用共享的后台线程池。
      • Dispatchers.IO: 适用于 I/O 密集型任务（如网络请求、文件操作），使用按需创建的线程池。
      • Dispatchers.Main: 适用于 Android 或 JavaFX 等 UI 框架，在主 UI 线程上执行。
      • Dispatchers.Unconfined: 不限制在任何特定线程，协程会在调用者线程上启动，并在第一个挂起点之后恢复时，由恢复它的线程决定。慎用。
    • 任务 (Job): 协程的句柄。你可以使用 Job 来取消协程或等待其完成。
    • 异常处理器 (CoroutineExceptionHandler): 处理未捕获的协程异常。

你可以使用 withContext 函数来切换协程上下文：

kotlin
suspend fun doSomething() = withContext(Dispatchers.IO) {
// 这个代码块将在 I/O 线程池中执行
downloadFile()
}

3. 结构化并发

结构化并发是 Kotlin Coroutines 的核心设计理念之一。它意味着协程的生命周期是分层和可预测的。一个父协程如果被取消，其所有子协程也会被自动取消。这极大地简化了错误处理和资源管理，避免了传统回调编程中常见的资源泄露和竞态条件问题。

kotlin
fun main() = runBlocking {
val job = launch {
try {
repeat(1000) { i ->
println("Job: I'm sleeping $i ...")
delay(500)
}
} finally {
println("Job: I'm running finally")
}
}
delay(1300) // 延迟一段时间
println("main: I'm tired of waiting!")
job.cancel() // 取消协程
job.join() // 等待协程完成其清理工作
println("main: Now I can quit.")
}
// 输出会显示在 main 协程取消 job 后，job 内部的 finally 块会被执行。

4. 协程的异常处理

协程的异常处理机制与同步代码类似，但有其特殊性。

  • launch 中的异常: 在 launch 构建器中，未捕获的异常通常会传播到父协程，如果父协程没有处理，则会传播到 CoroutineExceptionHandler 或导致应用程序崩溃（取决于上下文）。
  • async 中的异常: async 构建器中的异常会在调用 await() 方法时抛出。这意味着，如果一个 async 协程失败，但在其结果被 await() 之前，异常不会立即传播。

为了更好地处理异常，可以使用 try-catch 块或者 CoroutineExceptionHandler。

“`kotlin
fun main() = runBlocking {
val handler = CoroutineExceptionHandler { _, exception ->
println(“Caught $exception”)
}

val job = GlobalScope.launch(handler) { // 注意这里是 GlobalScope
    throw AssertionError("My Assertion Error")
}
val deferred = GlobalScope.async(handler) { // 注意这里是 GlobalScope
    throw ArithmeticException("My Arithmetic Exception")
}

job.join()
deferred.await() // 调用 await() 时才会抛出 ArithmeticException，但已被 handler 捕获

}
// 输出：
// Caught java.lang.AssertionError: My Assertion Error
// Caught java.lang.ArithmeticException: My Arithmetic Exception
``
请注意，在launch中使用CoroutineExceptionHandler通常是在顶层协程（如GlobalScope.launch或没有父协程的CoroutineScope.launch`）时生效。对于子协程，异常通常会传播到父协程。

5. 协程的取消与超时

  • 取消: 协程是协作式的取消。这意味着一个挂起函数必须检查协程是否被取消，并在取消时优雅地停止。Kotlin Coroutines 提供的许多挂起函数（如 delay、withContext）都是可取消的。对于长时间运行的计算，你可以使用 ensureActive() 或 yield() 来检查取消状态。

    kotlin
    val job = launch {
    repeat(1000) { i ->
    if (!isActive) { // 检查协程是否活跃
    return@launch
    }
    println("Job: I'm sleeping $i ...")
    delay(500)
    }
    }
    delay(1300)
    job.cancelAndJoin() // 取消并等待完成

  • 超时: 使用 withTimeout 或 withTimeoutOrNull 可以为协程操作设置超时。

    kotlin
    fun main() = runBlocking {
    withTimeout(1300L) {
    repeat(1000) { i ->
    println("I'm sleeping $i ...")
    delay(500L)
    }
    }
    }
    // 如果超过 1300ms，会抛出 TimeoutCancellationException

6. Flow (流)

Kotlin Coroutines 还引入了 Flow API，用于处理异步数据流。Flow 是一个冷流（Cold Stream），类似于 RxJava 的 Observable，但它是基于协程的，并且更加轻量和直观。它非常适合处理实时数据、用户事件或分页数据等场景。

“`kotlin
import kotlinx.coroutines.
import kotlinx.coroutines.flow.

fun simpleFlow(): Flow = flow {
println(“Flow started”)
for (i in 1..3) {
delay(100)
emit(i) // 发送数据
}
}

fun main() = runBlocking {
println(“Calling simpleFlow…”)
simpleFlow().collect { value -> // 收集数据
println(value)
}
println(“Collecting again…”)
simpleFlow().collect { value -> // Flow 是冷流，每次 collect 都会重新执行
println(value)
}
}
“`

7. 总结

Kotlin Coroutines 提供了一套强大、灵活且直观的异步编程工具。通过挂起函数、协程构建器、结构化并发和调度器，它极大地简化了并发代码的编写和维护。无论是在 Android 客户端、后端服务还是其他 JVM 应用程序中，Kotlin Coroutines 都是实现响应式和高性能应用程序的优秀选择。理解并熟练运用协程，将使开发者能够构建出更健壮、更易于理解的并发系统。

滚动至顶部