协程基础概念与执行模型
什么是协程
协程(Coroutine)是一种可以暂停执行、稍后恢复的函数。普通函数从头执行到尾,中间不能停下来;协程可以在执行过程中"挂起"自己,把控制权交还给调用者,调用者在合适的时候再"恢复"协程,让它从上次挂起的地方继续执行。
C++20 引入的协程是无栈协程(Stackless Coroutine)——协程挂起时不保留调用栈,而是把局部变量保存在堆上分配的协程帧(Coroutine Frame)中。这和有栈协程(如 Boost.Fiber)不同,无栈协程的开销更小,但只能在协程函数自身内部挂起,不能在它调用的子函数中挂起。
协程的三个关键字
C++20 用三个新关键字来标识协程操作:
| 关键字 | 作用 | 典型用途 |
|---|---|---|
co_await | 挂起协程,等待某个操作完成 | 异步 I/O、等待事件 |
co_yield | 挂起协程并产出一个值给调用者 | 生成器、惰性序列 |
co_return | 结束协程并返回最终值 | 返回计算结果 |
只要一个函数体内出现了这三个关键字中的任何一个,编译器就把它当作协程处理。
协程的核心组件
协程涉及三个核心对象,它们各自的职责不同:
调用者 <---> 返回对象(Return Object)
|
v
协程句柄(coroutine_handle)
|
v
承诺对象(promise_type)
|
v
协程帧(Coroutine Frame,堆上分配)
|
v
协程函数体(用户代码)| 组件 | 类型 | 谁管理 | 作用 |
|---|---|---|---|
| 承诺对象(Promise) | 用户定义的 promise_type | 编译器创建,用户定义行为 | 控制协程的启动、挂起、结束行为 |
| 协程句柄(Handle) | std::coroutine_handle<promise_type> | 用户通过返回对象间接持有 | 恢复或销毁协程 |
| 返回对象(Return Object) | 用户定义的类型 | 调用者持有 | 对外提供访问协程结果的接口 |
| 协程帧(Frame) | 编译器内部 | 编译器分配,用户通过句柄销毁 | 存储局部变量、承诺对象、挂起点 |
协程的执行流程
调用协程函数
|
v
分配协程帧(堆上)
|
v
构造承诺对象(promise_type)
|
v
调用 promise.get_return_object() → 创建返回对象
|
v
co_await promise.initial_suspend()
|
+--- suspend_always → 协程挂起,返回对象给调用者(惰性启动)
+--- suspend_never → 继续执行协程体
|
v
执行协程体 {
遇到 co_await expr → 可能挂起
遇到 co_yield expr → 调用 promise.yield_value(expr),然后挂起
遇到 co_return expr → 调用 promise.return_value(expr),然后进入最终挂起
遇到 co_return; → 调用 promise.return_void(),然后进入最终挂起
异常抛出 → 调用 promise.unhandled_exception()
}
|
v
co_await promise.final_suspend() (最终挂起点)
|
+--- suspend_always → 协程挂起但不销毁(调用者负责销毁)
+--- suspend_never → 协程自动销毁帧基本示例
#include <coroutine>
#include <iostream>
#include <string>
// ============================
// 示例1:最简单的协程——什么都不做
// ============================
// 返回对象类型
struct SimpleTask {
// 承诺类型——协程的"控制面板"
struct promise_type {
// 创建返回对象
SimpleTask get_return_object() {
return SimpleTask{
std::coroutine_handle<promise_type>::from_promise(*this)
};
}
// 协程开始时挂起(惰性启动)
std::suspend_always initial_suspend() noexcept { return {}; }
// 协程结束时挂起(调用者负责销毁)
std::suspend_always final_suspend() noexcept { return {}; }
// 协程没有返回值
void return_void() {}
// 处理未捕获的异常
void unhandled_exception() { std::terminate(); }
};
// 持有协程句柄
std::coroutine_handle<promise_type> handle_;
// 构造函数
explicit SimpleTask(std::coroutine_handle<promise_type> h) : handle_(h) {}
// 析构时销毁协程帧
~SimpleTask() {
if (handle_) handle_.destroy();
}
// 禁止复制
SimpleTask(const SimpleTask&) = delete;
SimpleTask& operator=(const SimpleTask&) = delete;
// 允许移动
SimpleTask(SimpleTask&& other) noexcept : handle_(other.handle_) {
other.handle_ = nullptr;
}
// 恢复协程执行
void resume() {
if (handle_ && !handle_.done()) {
handle_.resume();
}
}
// 检查协程是否已完成
bool done() const {
return !handle_ || handle_.done();
}
};
// 协程函数——函数体中有 co_return,编译器把它当协程处理
SimpleTask simple_coroutine() {
std::cout << "协程开始执行" << std::endl;
co_return; // 结束协程
}
void simple_demo() {
std::cout << "创建协程" << std::endl;
auto task = simple_coroutine(); // 创建协程,但因为 initial_suspend 返回 suspend_always,不会立即执行
std::cout << "协程已创建但尚未执行" << std::endl;
task.resume(); // 恢复执行,输出 "协程开始执行"
std::cout << "协程已完成: " << std::boolalpha << task.done() << std::endl;
}
// ============================
// 示例2:简单生成器
// ============================
struct Generator {
struct promise_type {
int current_value; // 当前产出的值
Generator get_return_object() {
return Generator{
std::coroutine_handle<promise_type>::from_promise(*this)
};
}
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
// co_yield 会调用这个方法
std::suspend_always yield_value(int value) {
current_value = value; // 保存产出的值
return {}; // 挂起协程
}
void return_void() {}
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> handle_;
explicit Generator(std::coroutine_handle<promise_type> h) : handle_(h) {}
~Generator() {
if (handle_) handle_.destroy();
}
Generator(const Generator&) = delete;
Generator& operator=(const Generator&) = delete;
Generator(Generator&& other) noexcept : handle_(other.handle_) {
other.handle_ = nullptr;
}
// 获取下一个值
bool next() {
if (handle_ && !handle_.done()) {
handle_.resume();
return !handle_.done();
}
return false;
}
// 获取当前值
int value() const {
return handle_.promise().current_value;
}
};
// 生成器协程:产出 0 到 n-1 的整数序列
Generator range(int n) {
for (int i = 0; i < n; ++i) {
co_yield i; // 产出一个值然后挂起
}
// 隐式 co_return;
}
// 斐波那契数列生成器
Generator fibonacci(int count) {
int a = 0, b = 1;
for (int i = 0; i < count; ++i) {
co_yield a; // 产出当前值
int next = a + b; // 计算下一个值
a = b;
b = next;
}
}
void generator_demo() {
std::cout << "range(5): ";
auto gen = range(5);
while (gen.next()) {
std::cout << gen.value() << " ";
}
std::cout << std::endl;
std::cout << "fibonacci(8): ";
auto fib = fibonacci(8);
while (fib.next()) {
std::cout << fib.value() << " ";
}
std::cout << std::endl;
}
// ============================
// 示例3:多次挂起和恢复
// ============================
SimpleTask multi_suspend() {
std::cout << "步骤 1" << std::endl;
co_await std::suspend_always{}; // 手动挂起
std::cout << "步骤 2" << std::endl;
co_await std::suspend_always{}; // 再次挂起
std::cout << "步骤 3" << std::endl;
// 隐式 co_return;
}
void multi_suspend_demo() {
auto task = multi_suspend();
std::cout << "--- resume 1 ---" << std::endl;
task.resume(); // 执行步骤 1,然后挂起
std::cout << "--- resume 2 ---" << std::endl;
task.resume(); // 执行步骤 2,然后挂起
std::cout << "--- resume 3 ---" << std::endl;
task.resume(); // 执行步骤 3,然后结束
}
int main() {
std::cout << "=== 简单协程 ===" << std::endl;
simple_demo();
std::cout << "\n=== 生成器 ===" << std::endl;
generator_demo();
std::cout << "\n=== 多次挂起 ===" << std::endl;
multi_suspend_demo();
return 0;
}协程 vs 普通函数 vs 线程
| 方面 | 普通函数 | 协程 | 线程 |
|---|---|---|---|
| 执行方式 | 一次性从头到尾 | 可挂起和恢复 | 并行执行 |
| 状态保存 | 栈帧(函数返回即销毁) | 协程帧(堆上) | 独立栈 |
| 切换开销 | 无 | 很小(函数调用级别) | 较大(系统调用级别) |
| 并发模型 | 无 | 协作式(主动让出) | 抢占式(OS 调度) |
| 内存开销 | 栈帧大小 | 协程帧大小(通常很小) | 完整线程栈(默认 1-8 MB) |
适用场景
- 异步 I/O:网络读写、文件操作等需要等待的场景
- 生成器:惰性产出序列中的元素(斐波那契、文件行读取等)
- 状态机:用顺序代码表达复杂的状态转换逻辑
- 事件驱动编程:在事件循环中用协程替代回调
- 流式处理:管道式的数据变换
常见问题
C++20 协程开箱就能用吗?
不完全是。C++20 只提供了协程的底层机制(三个关键字、coroutine_handle、coroutine_traits、suspend_always/suspend_never),没有提供现成的 Task、Generator 等高层类型。你需要自己写返回对象和 promise_type,或者使用第三方库(如 cppcoro)。C++23 引入了 std::generator,算是标准库的第一个协程工具类型。
协程帧一定分配在堆上吗?
语义上是的。但编译器可以在确定协程的生命周期完全嵌套在调用者中时,将帧分配优化掉("Heap Allocation Elision",HALO)。是否真的优化取决于编译器实现。
协程可以递归调用自己吗?
可以,但要注意每次递归都会分配一个新的协程帧。如果递归很深,堆内存消耗会很大。
initial_suspend 返回 suspend_always 和 suspend_never 有什么区别?
suspend_always 表示协程创建后立即挂起(惰性启动),调用者需要手动 resume() 才开始执行。suspend_never 表示协程创建后立即开始执行,直到遇到第一个挂起点。惰性启动更常用,因为它让调用者完全控制执行时机。
注意事项
- 协程函数不能用
return,必须用co_return - 协程不能是
constexpr、consteval函数 - 协程不能是构造函数、析构函数、
main函数 - 协程不能使用可变参数(variadic arguments)
final_suspend()必须是noexcept的- 协程句柄是非拥有的(non-owning),销毁责任需要明确
- 恢复一个已完成的协程是未定义行为
- 协程帧的生命周期管理是容易出错的地方,需要格外注意
编译器支持情况
| 编译器 | 最低支持版本 | 头文件 |
|---|---|---|
| GCC | 10.0 | <coroutine> |
| Clang | 14.0(完整支持) | <coroutine> |
| MSVC | 19.28 (VS 2019 16.8) | <coroutine> |
总结
C++20 协程是一种可以挂起和恢复的函数,通过 co_await、co_yield、co_return 三个关键字来标识挂起点和结束点。协程的执行由三个核心组件协调:承诺对象(promise_type)控制协程的生命周期行为,协程句柄(coroutine_handle)让外部代码恢复或销毁协程,返回对象是调用者拿到的接口。协程是无栈的,挂起时状态保存在堆上的协程帧中,切换开销比线程小得多。C++20 的协程设计偏底层——提供了机制但不提供策略,你需要自己定义 promise_type 和返回类型来控制协程的具体行为。