Kotlin 协程基础 03：结构化并发 (Structured Concurrency)

1 - Kotlin, 1.2 - Kotlin 协程基础 本文总阅读量次

在 Kotlin 协程中，coroutineScope 是实现结构化并发的核心构建器。它允许我们在挂起函数内部安全地启动新的协程，并确保任务的生命周期受到严格管理。

1. 核心概念：什么是结构化并发？

结构化并发意味着：在一个作用域内启动的协程，其生命周期被限制在该作用域内。父协程会等待所有子协程完成后才结束。

coroutineScope 的核心作用

  • 建立任务边界：它定义了一个局部作用域。在此块内启动的所有子协程（通过 launch 或 async）必须在 coroutineScope 块结束前全部完成。
  • **非阻塞式挂起 (Thread-Friendly)**：它是一个 suspend 函数。当它等待子协程完成时，它会释放当前线程供其他任务使用，而不会造成线程阻塞。
  • 异常联动与传播：
    • 如果作用域内的任何一个子协程失败，整个作用域会立即取消其他子协程。
    • 它会将异常向上抛出给调用者，保证了任务的原子性。

2. 实际编码中的使用场景

场景 A：并行分解任务（多接口并发调用）

这是最常见的性能优化场景。当你需要同时从多个数据源获取数据，并等待所有结果返回后刷新 UI 时：

1
2
3
4
5
6
7
8
9
10
11
12
suspend fun loadDashboardData() = coroutineScope {
    // 1. 同时发起两个异步请求
    val userDeferred = async { api.getUserInfo() }    
    val postsDeferred = async { api.getRecentPosts() }

    // 2. 等待两个结果都准备好
    // 如果其中一个接口报错，另一个会自动取消，避免浪费资源
    val user = userDeferred.await()
    val posts = postsDeferred.await()

    updateUI(user, posts)
}

场景 B：保证挂起函数的内部完整性

当你封装一个复杂的异步业务逻辑时，使用 coroutineScope 可以确保：当该函数返回时，它内部启动的所有后台任务已经彻底结束。这能有效防止“协程泄漏”（即函数执行完了，但后台仍有任务在跑，占用内存）。

3. coroutineScope vs runBlocking

特性 coroutineScope runBlocking
性质 挂起函数 (suspend) 普通函数
线程行为 非阻塞：释放线程供其他任务使用 阻塞：死等直到内部逻辑完成
使用位置 业务逻辑、其他挂起函数内部 main 函数、单元测试、桥接代码
目的 并行化任务、局部作用域管理 启动顶层协程、阻塞线程等待

4. 代码解析 (example-basic-03.kt)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fun main() = runBlocking {
    println("Program starting...")
    doWorld()
    println("Done!") 
}

// 使用 coroutineScope 封装逻辑
suspend fun doWorld() = coroutineScope { 
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello")
}

执行流程分析：

  1. main 调用 doWorld。
  2. doWorld 进入 coroutineScope。
  3. launch 启动子协程（准备延迟 1 秒）。
  4. 立即打印 Hello（主流程不等待 launch）。
  5. coroutineScope 挂起，等待其内部 launch 完成。
  6. 1 秒后打印 **World!**。
  7. 所有子协程完成，coroutineScope 返回，doWorld 结束。
  8. main 打印 Done! 并退出。

5. 开发者感悟

coroutineScope 是 Android 开发中处理并发任务的推荐做法。它不仅让代码逻辑看起来像同步代码一样清晰，更重要的是它通过“结构化”的约束，从根源上解决了异步任务管理混乱和内存泄漏的问题。

1 - Kotlin, 1.2 - Kotlin 协程基础