一、什么是协程?
协程(Coroutine)是一种可以主动或通过调度机制暂停执行,并在之后从暂停位置恢复执行的程序执行单元。
与传统函数不同,普通函数通常从入口开始执行,直到返回后结束;协程则可以在执行过程中保存必要的状态,暂时让出执行权,之后继续运行。
例如,一个网络请求任务可能经历以下过程:
- 发起网络请求。
- 等待服务器返回数据。
- 在等待期间暂停当前协程。
- 执行其他就绪任务。
- 网络数据到达后恢复协程。
- 继续处理响应结果。
协程的核心特征包括:
- 可暂停:执行到特定位置时,可以暂时挂起。
- 可恢复:恢复后能够从上次暂停的位置继续执行。
- 状态保存:暂停期间保留局部变量、执行位置等必要状态。
- 轻量调度:通常由语言运行时、协程库或执行器管理,不一定需要操作系统创建独立线程。
- 协作式执行:许多协程实现依赖显式挂起点或让出执行权。
需要注意:协程是一种执行模型,不等于线程,也不必然意味着并行执行。
二、协程与普通函数的区别
普通函数和协程都可以封装一段可复用的逻辑,但它们的执行生命周期不同。
| 对比维度 | 普通函数 | 协程 |
|---|---|---|
| 执行方式 | 调用后执行至返回 | 可以暂停并恢复 |
| 状态保存 | 通常由调用栈维护 | 需要保存可恢复的执行状态 |
| 控制权 | 通常由调用者获得返回结果 | 可以在挂起点让出控制权 |
| 执行生命周期 | 一次调用通常连续执行 | 可以跨多个调度阶段执行 |
| 调度方式 | 由调用关系决定 | 可由运行时或调度器管理 |
| 并发能力 | 通常需要额外机制 | 适合组织大量并发任务 |
例如,普通函数:
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 决定协程在哪类执行上下文中运行。