返回专栏
· 17 分钟阅读

协程(Coroutine):轻量级并发执行机制


一、什么是协程?

协程(Coroutine)是一种可以主动或通过调度机制暂停执行,并在之后从暂停位置恢复执行的程序执行单元。

与传统函数不同,普通函数通常从入口开始执行,直到返回后结束;协程则可以在执行过程中保存必要的状态,暂时让出执行权,之后继续运行。

例如,一个网络请求任务可能经历以下过程:

  1. 发起网络请求。
  2. 等待服务器返回数据。
  3. 在等待期间暂停当前协程。
  4. 执行其他就绪任务。
  5. 网络数据到达后恢复协程。
  6. 继续处理响应结果。

协程的核心特征包括:

  • 可暂停:执行到特定位置时,可以暂时挂起。
  • 可恢复:恢复后能够从上次暂停的位置继续执行。
  • 状态保存:暂停期间保留局部变量、执行位置等必要状态。
  • 轻量调度:通常由语言运行时、协程库或执行器管理,不一定需要操作系统创建独立线程。
  • 协作式执行:许多协程实现依赖显式挂起点或让出执行权。

需要注意:协程是一种执行模型,不等于线程,也不必然意味着并行执行。

二、协程与普通函数的区别

普通函数和协程都可以封装一段可复用的逻辑,但它们的执行生命周期不同。

对比维度 普通函数 协程
执行方式 调用后执行至返回 可以暂停并恢复
状态保存 通常由调用栈维护 需要保存可恢复的执行状态
控制权 通常由调用者获得返回结果 可以在挂起点让出控制权
执行生命周期 一次调用通常连续执行 可以跨多个调度阶段执行
调度方式 由调用关系决定 可由运行时或调度器管理
并发能力 通常需要额外机制 适合组织大量并发任务

例如,普通函数:

def download():
    print("开始下载")
    data = request_data()
    print("下载完成")
    return data

在同步调用中,request_data() 如果阻塞,当前线程通常需要等待它返回。

使用 Python 的异步协程:

import asyncio

async def download():
    print("开始下载")
    data = await request_data()
    print("下载完成")
    return data

这里的 await 可以在等待异步操作时挂起当前协程,让事件循环调度其他就绪任务。

注意,async def 定义的是 Python 异步函数。调用它会创建协程对象,而不是立即执行函数体。

async def hello():
    print("Hello")

coro = hello()
print(coro)

只有将协程交给事件循环运行,例如通过 asyncio.run()、asyncio.create_task() 或 await,它才会开始执行。

三、协程的核心工作机制

协程能够暂停和恢复,关键在于运行时保存执行状态,并在合适的时机重新调度。

1. 协程状态

一个典型协程可以具有以下状态:

状态 含义
Created 已创建,尚未开始执行
Ready 已准备好运行,等待调度
Running 正在执行
Suspended 已暂停,等待某个条件或事件
Completed 执行完成
Failed 执行过程中发生未处理异常
Cancelled 已取消,具体状态模型取决于实现

不同语言的状态名称和状态转换规则可能不同,但基本思想相似。

2. 协程状态转换

以下是一个简化的协程生命周期:

flowchart TD
    A["创建协程"] --> B["Ready 就绪"]
    B --> C["Running 执行"]
    C --> D{"是否需要挂起"}
    D -->|"是"| E["Suspended 暂停"]
    E --> F{"恢复条件是否满足"}
    F -->|"否"| E
    F -->|"是"| B
    D -->|"否,执行完成"| G["Completed 完成"]
    C --> H["发生未处理异常"]
    H --> I["Failed 失败"]
    B --> J["取消任务"]
    C --> J
    E --> J
    J --> K["Cancelled 取消"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style I fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style J fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style K fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这是概念模型,并不意味着所有语言都采用完全相同的状态枚举或调度策略。

3. 协程如何保存执行状态?

协程暂停时,运行时必须保存恢复执行所需的信息。

典型信息包括:

  • 当前执行到哪个位置。
  • 局部变量的值。
  • 当前协程的上下文。
  • 尚未完成的异步操作。
  • 异常处理和清理相关状态。

例如:

async def process():
    user_id = 1001
    user = await fetch_user(user_id)
    result = await process_user(user)
    return result

当执行到第一个 await 时,协程可能暂停。

为了之后能够继续执行,运行时需要保留 user_id、当前执行位置等必要状态。

当 fetch_user() 对应的异步操作完成后,协程可以恢复执行,并继续处理用户数据。

4. 协程为什么可以减少线程开销?

传统线程通常由操作系统进行调度。线程切换可能涉及内核调度、寄存器状态保存和恢复,以及线程栈等资源。

许多协程实现则采用用户态调度:

  • 协程由运行时或协程库管理。
  • 多个协程可以复用少量线程。
  • 协程在挂起点主动让出执行权。
  • 调度器选择其他就绪协程执行。

这种方式能够降低大量并发任务的管理成本。

但需要注意:

协程并不意味着完全没有栈空间和上下文开销。

不同语言的协程实现差异很大:

  • 有些使用独立栈(Stackful Coroutine)。
  • 有些使用状态机保存局部状态(Stackless Coroutine)。
  • 有些采用混合实现。
  • 有些协程运行时仍然依赖操作系统线程完成底层 I/O。

四、协程的调度机制

协程本身提供暂停和恢复能力,调度器则决定什么时候运行哪个协程。

1. 协作式调度

协作式调度(Cooperative Scheduling)要求协程在适当位置主动让出执行权。

常见挂起点包括:

  • await 等待异步操作。
  • yield 主动让出执行权。
  • 运行时提供的协程挂起操作。

例如:

import asyncio

async def task_a():
    for i in range(3):
        print("A", i)
        await asyncio.sleep(1)

async def task_b():
    for i in range(3):
        print("B", i)
        await asyncio.sleep(1)

async def main():
    await asyncio.gather(task_a(), task_b())

asyncio.run(main())

两个协程在等待期间可以交替获得执行机会。

需要特别注意:asyncio.sleep(1) 是异步等待,不会像 time.sleep(1) 那样阻塞当前线程。

2. 调度器的基本工作流程

以事件循环驱动的异步协程为例:

flowchart TD
    A["创建异步任务"] --> B["加入就绪队列"]
    B --> C["事件循环选择任务"]
    C --> D["执行协程"]
    D --> E{"是否遇到挂起点"}
    E -->|"否"| F{"任务是否完成"}
    F -->|"否"| D
    F -->|"是"| G["记录任务结果"]
    E -->|"是"| H["注册等待条件"]
    H --> I["执行其他就绪任务"]
    I --> J{"等待条件是否满足"}
    J -->|"否"| I
    J -->|"是"| K["将任务重新加入就绪队列"]
    K --> C

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style J fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style K fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

典型事件循环会管理就绪任务、定时器、I/O 事件和任务完成通知。

需要注意,事件循环只是常见的协程调度方式之一,并不是所有协程都必须由事件循环驱动。

3. 协作式调度的局限

协作式调度有一个重要特点:协程如果长时间不主动挂起,就可能占用当前执行线程。

例如:

async def bad_task():
    while True:
        calculate_heavy_data()

虽然函数被声明为 async,但内部没有真正的挂起点。

如果 calculate_heavy_data() 长时间执行,事件循环就无法及时调度其他任务。

这会导致:

  • 其他协程延迟执行。
  • 网络请求响应变慢。
  • 定时任务无法准时运行。
  • 整个事件循环出现阻塞。

对于 CPU 密集型任务,可以考虑使用进程池、线程池或其他并行计算方案。

五、协程、线程与进程的区别

协程、线程和进程都可以用于组织并发任务,但它们处于不同层次。

对比维度 进程 线程 协程
管理主体 操作系统 操作系统 通常由运行时或协程库
资源隔离 通常具有独立地址空间 同进程线程共享地址空间 取决于所在进程和运行时
调度主体 操作系统 操作系统 通常由用户态调度器
创建与切换成本 通常较高 通常低于进程 通常较低
执行关系 可并行 可并行 是否并行取决于运行时和线程配置
通信方式 IPC 等 共享内存、同步原语 消息传递、共享状态、异步队列等
典型用途 服务隔离、独立任务 多线程计算、后台工作 大量 I/O 并发任务

1. 进程

进程是操作系统资源分配和保护的重要单位。

每个进程通常具有独立的虚拟地址空间,以及自己的文件描述符、内存映射等资源。

多个进程可以在多核 CPU 上真正并行运行。

2. 线程

线程是操作系统调度执行的基本单位之一。

同一进程中的多个线程共享进程地址空间,但各自具有执行上下文和线程栈。

多个线程可以同时运行在不同 CPU 核心上,实现并行计算。

3. 协程

协程是更轻量的执行单元,通常运行在某个线程之上。

一个线程可以承载大量协程,协程之间通过挂起和恢复实现任务切换。

但协程是否可以跨线程运行、是否能够并行执行,取决于具体运行时的设计。

4. 三者的关系

一个典型的多层并发架构可以表示为:

flowchart TB
    A["操作系统"]
    A --> B["进程 A"]
    A --> C["进程 B"]
    B --> D["线程 1"]
    B --> E["线程 2"]
    C --> F["线程 3"]
    D --> G["协程 A1"]
    D --> H["协程 A2"]
    D --> I["协程 A3"]
    E --> J["协程 B1"]
    E --> K["协程 B2"]
    F --> L["协程 C1"]
    F --> M["协程 C2"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style J fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style K fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style L fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style M fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这是用于理解层次关系的示意图。实际运行时不一定采用固定的一对多映射,也可能允许协程在线程之间迁移。

六、协程与异步编程的关系

协程和异步编程经常一起出现,但两者并不是同一个概念。

异步编程是一种编程模型,协程是一种可以实现异步编程的执行机制。

异步编程关注的是:

  • 任务不必阻塞等待结果。
  • 多个操作可以重叠执行。
  • 任务完成后通过回调、事件或其他机制通知调用方。

协程关注的是:

  • 如何暂停当前执行。
  • 如何保存执行状态。
  • 如何恢复执行。
  • 如何组织任务的生命周期。

常见异步编程方式包括:

方式 核心机制 特点
回调函数 操作完成后调用回调 容易出现嵌套和控制流分散
Promise / Future 使用对象表示未来结果 便于组合异步操作
协程 暂停与恢复执行 控制流接近同步代码
事件驱动 通过事件触发处理逻辑 适合事件密集型系统

需要注意:

  • 协程可以用于异步编程,但不是所有异步操作都必须使用协程。
  • 异步操作可以通过回调或 Promise 实现。
  • 某些语言中的协程也可以用于生成器、任务调度和控制流管理,而不只是异步 I/O。

协程与 Async / Await

在许多现代语言中,async 和 await 是使用协程的重要语法形式。

例如:

import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch_data()
    print(result)

asyncio.run(main())

其中:

  • async def 声明异步函数。
  • 调用异步函数会产生协程对象。
  • await 等待一个可等待对象,并可能挂起当前协程。
  • asyncio.run() 创建并运行事件循环,驱动顶层协程。

await 并不意味着当前线程一定被阻塞。对于正常的异步等待,当前协程会挂起,事件循环可以继续运行其他任务。

七、不同语言中的协程实现

协程不是某一种语言独有的特性。不同语言提供了不同的语法、调度方式和运行时支持。

1. Python:asyncio 协程

Python 使用 async 和 await 定义原生异步协程。

import asyncio

async def fetch_user(user_id):
    await asyncio.sleep(1)
    return {"id": user_id, "name": "Alice"}

async def main():
    tasks = [
        asyncio.create_task(fetch_user(1)),
        asyncio.create_task(fetch_user(2)),
        asyncio.create_task(fetch_user(3))
    ]

    users = await asyncio.gather(*tasks)
    print(users)

asyncio.run(main())

特点:

  • 使用 async def 声明协程函数。
  • 使用 await 挂起当前协程。
  • 使用 asyncio.create_task() 创建并调度任务。
  • 使用 asyncio.gather() 等方式组合并发任务。
  • 通常由单线程事件循环调度协程,但也可以结合线程池和进程池。

注意,asyncio 的协程调度通常是协作式的。同步阻塞调用如果发生在事件循环线程中,可能阻塞整个事件循环。

2. JavaScript:async 函数与 Promise

JavaScript 使用 async 和 await 提供类似协程的异步控制流。

async function fetchUser(id) {
    const response = await fetch(`/api/users/${id}`);
    return await response.json();
}

async function main() {
    const user1 = await fetchUser(1);
    const user2 = await fetchUser(2);

    console.log(user1, user2);
}

main();

JavaScript 的 async 函数返回 Promise。

await 会暂停当前 async 函数的后续执行,并在 Promise 兑现或拒绝后继续处理结果。

这里需要区分:

  • Promise 是对未来结果的表示。
  • async / await 是组织异步控制流的语法。
  • JavaScript 引擎会通过内部机制管理暂停和恢复。
  • 普通 JavaScript 主线程中的 async 函数不会因为使用 async 就自动获得多线程并行能力。

3. Go:Goroutine

Go 提供 Goroutine 作为轻量级并发执行单元。

package main

import (
    "fmt"
    "time"
)

func worker(id int) {
    for i := 0; i < 3; i++ {
        fmt.Println("worker", id, i)
        time.Sleep(time.Second)
    }
}

func main() {
    go worker(1)
    go worker(2)

    time.Sleep(4 * time.Second)
}

特点:

  • 使用 go 关键字启动 Goroutine。
  • Goroutine 由 Go 运行时调度。
  • 多个 Goroutine 可以复用较少的操作系统线程。
  • Go 运行时可以将 Goroutine 调度到不同线程执行。
  • 在多核环境下,Goroutine 可以实现真正的并行执行。

Go 的调度器通常通过 G、M、P 三个核心概念描述:

概念 含义
G Goroutine,代表一个并发执行任务
M Machine,代表操作系统线程
P Processor,代表执行 Go 代码所需的调度资源

G、M、P 模型是理解 Go 调度器的重要抽象,但其具体实现会随 Go 运行时版本演进。

4. Kotlin:协程

Kotlin 通过协程支持挂起函数、结构化并发和异步任务组合。

import kotlinx.coroutines.*

suspend fun fetchUser(id: Int): String {
    delay(1000)
    return "User $id"
}

fun main() = runBlocking {
    val user1 = async { fetchUser(1) }
    val user2 = async { fetchUser(2) }

    println(user1.await())
    println(user2.await())
}

特点:

  • 使用 suspend 声明可挂起函数。
  • 使用 launch 启动不直接返回结果的协程任务。
  • 使用 async 创建返回结果的协程任务。
  • 使用 await() 获取异步计算结果。
  • 通过 CoroutineDispatcher 决定协程在哪类执行上下文中运行。