无栈协程特性与限制
什么是无栈协程
C++20 的协程是无栈协程(Stackless Coroutine)。"无栈"指的是协程挂起时不保留完整的调用栈,而是把需要跨挂起点保留的局部变量存储在堆上分配的协程帧(Coroutine Frame)中。协程恢复时从协程帧中恢复状态,继续在调用者的栈上执行。
与之对应的是有栈协程(Stackful Coroutine),比如 Boost.Coroutine2 和 Boost.Fiber,它们为每个协程分配一个独立的栈空间,可以在调用栈的任意深度挂起。
无栈 vs 有栈协程
| 特性 | 无栈协程(C++20) | 有栈协程(Boost.Fiber 等) |
|---|---|---|
| 挂起位置 | 只能在协程函数自身内部挂起 | 可以在调用栈的任意深度挂起 |
| 状态存储 | 协程帧(堆上,编译器管理) | 独立栈空间(预分配) |
| 内存开销 | 很小(只存需要的变量,通常几十到几百字节) | 较大(需要预分配栈,通常几十 KB 到几 MB) |
| 切换开销 | 极小(函数调用级别) | 较小但比无栈大(需要切换栈指针) |
| 编译器优化 | 可以内联和优化(HALO) | 难以跨协程优化 |
| 传染性 | 有(调用链上层也要改成协程) | 无(普通函数也能挂起) |
| 标准支持 | C++20 标准 | 第三方库 |
无栈协程的核心特性
编译器驱动的状态机转换
编译器把协程函数转换成一个状态机。每个 co_await、co_yield 是一个状态转换点。局部变量中只有跨挂起点存活的变量会被保存到协程帧中,其他变量仍然使用栈。
// 用户写的协程
Generator<int> example() {
int a = 1; // 跨挂起点,存入协程帧
co_yield a;
int b = 2; // 跨挂起点,存入协程帧
co_yield a + b;
int c = 3; // 不跨挂起点(之后没有挂起),可能留在栈上
}
// 编译器大致生成的状态机(伪代码)
void example_resume(CoroutineFrame* frame) {
switch (frame->state) {
case 0:
frame->a = 1;
frame->state = 1;
return; // 挂起
case 1:
frame->b = 2;
frame->state = 2;
return; // 挂起
case 2:
// c = 3 不需要保存
frame->state = 3; // 完成
return;
}
}堆分配消除(HALO)
HALO(Heap Allocation eLision Optimization)是编译器的一种优化:当编译器能证明协程帧的生命周期完全嵌套在调用者的栈帧中时,可以把协程帧分配在栈上而不是堆上,完全消除动态内存分配。
HALO 生效的条件:
- 协程的创建和销毁在同一个函数中
- 编译器能内联协程的 ramp 函数(初始化部分)
- 编译器能看到协程帧不会逃逸出当前作用域
// HALO 可能生效的场景
void process() {
auto gen = range(1, 10); // 创建
while (gen.next()) { // 使用
std::cout << gen.value();
}
// gen 析构,协程帧销毁 // 销毁在同一函数
}
// HALO 不太可能生效的场景
Generator<int> create_generator() {
return range(1, 10); // 协程帧逃逸出函数
}自定义内存分配
可以在 promise_type 中重载 operator new 和 operator delete 来控制协程帧的分配策略:
#include <coroutine>
#include <iostream>
#include <cstdlib>
struct PoolTask {
struct promise_type {
PoolTask get_return_object() {
return PoolTask{
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(); }
// 自定义协程帧分配
static void* operator new(std::size_t size) {
std::cout << "分配协程帧: " << size << " 字节" << std::endl;
return std::malloc(size);
}
static void operator delete(void* ptr, std::size_t size) {
std::cout << "释放协程帧: " << size << " 字节" << std::endl;
std::free(ptr);
}
};
std::coroutine_handle<promise_type> handle_;
explicit PoolTask(std::coroutine_handle<promise_type> h) : handle_(h) {}
~PoolTask() { if (handle_) handle_.destroy(); }
PoolTask(const PoolTask&) = delete;
PoolTask& operator=(const PoolTask&) = delete;
PoolTask(PoolTask&& o) noexcept : handle_(o.handle_) { o.handle_ = nullptr; }
void resume() { if (handle_ && !handle_.done()) handle_.resume(); }
};
PoolTask pool_coroutine() {
std::cout << "协程执行中" << std::endl;
co_return;
}
void allocation_demo() {
auto task = pool_coroutine(); // 输出分配信息
task.resume();
// 析构时输出释放信息
}无栈协程的限制
不能在子函数中挂起
这是无栈协程最大的限制。co_await、co_yield、co_return 只能出现在协程函数自身的函数体中,不能出现在协程调用的普通函数中。
// 错误:不能在子函数中使用 co_await
void helper() {
co_await std::suspend_always{}; // 编译错误:helper 不是协程
}
Task my_coroutine() {
helper(); // helper 中不能挂起
co_return;
}
// 正确做法:把子函数也改成协程
Task helper_coroutine() {
co_await std::suspend_always{}; // 可以
co_return;
}
Task my_coroutine() {
co_await helper_coroutine(); // 等待子协程完成
co_return;
}这种特性被称为"传染性"——一旦某个函数需要挂起,它自身和调用链上的所有函数都可能需要变成协程。
语法限制
| 限制 | 说明 |
|---|---|
不能用 return | 协程中必须用 co_return |
| 不能用可变参数 | void f(int, ...) 不能是协程 |
不能是 constexpr / consteval | 协程不能在编译期求值 |
| 不能是构造函数/析构函数 | 构造函数和析构函数不能是协程 |
不能是 main 函数 | main 不能是协程 |
| 不能用占位符返回类型推导 | auto f() { co_return 1; } 在某些情况下不合法 |
协程帧的堆分配
默认情况下,每次调用协程函数都会在堆上分配一个协程帧。虽然 HALO 优化可以在某些情况下消除堆分配,但这不是标准保证的——完全取决于编译器实现和优化级别。在 debug 模式下,HALO 几乎不会生效。
没有标准的高层工具
C++20 只提供了协程的底层机制(coroutine_handle、coroutine_traits、suspend_always/suspend_never),没有提供现成的 Task、Generator 等工具类型。开发者需要自己实现或依赖第三方库。C++23 引入了 std::generator,但 Task 类型到 C++26 仍在提案中。
调试困难
协程的状态机转换是编译器生成的,调试时难以跟踪协程的执行流程。断点、单步执行等调试手段在协程的挂起/恢复点附近可能表现不直观。
基本示例
#include <coroutine>
#include <iostream>
#include <vector>
#include <string>
// ============================
// 演示传染性问题及解决方案
// ============================
// 基础 Task 类型
struct Task {
struct promise_type {
Task get_return_object() {
return Task{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 Task(std::coroutine_handle<promise_type> h) : handle_(h) {}
~Task() { if (handle_) handle_.destroy(); }
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
Task(Task&& o) noexcept : handle_(o.handle_) { o.handle_ = nullptr; }
void resume() { if (handle_ && !handle_.done()) handle_.resume(); }
bool done() const { return !handle_ || handle_.done(); }
// 让 Task 可以被 co_await
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> caller) {
handle_.resume(); // 简化实现:直接运行子协程到完成
}
void await_resume() const noexcept {}
};
// 传染性示例:底层操作需要异步 → 所有调用者都变成协程
Task low_level_io() {
std::cout << " 底层 I/O 操作" << std::endl;
co_await std::suspend_always{}; // 模拟异步等待
std::cout << " I/O 完成" << std::endl;
}
Task mid_level_process() {
std::cout << "中间层处理开始" << std::endl;
co_await low_level_io(); // 必须也是协程才能等待子协程
std::cout << "中间层处理结束" << std::endl;
}
Task high_level_action() {
std::cout << "高层操作开始" << std::endl;
co_await mid_level_process(); // 同样必须是协程
std::cout << "高层操作结束" << std::endl;
}
void infection_demo() {
auto task = high_level_action();
// 需要反复 resume 来驱动整个链条
while (!task.done()) {
task.resume();
}
}
// ============================
// 演示协程帧大小的影响因素
// ============================
template<typename T>
struct Generator {
struct promise_type {
T 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 {}; }
std::suspend_always yield_value(T value) {
current_value = std::move(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&& o) noexcept : handle_(o.handle_) { o.handle_ = nullptr; }
bool next() {
if (handle_ && !handle_.done()) { handle_.resume(); return !handle_.done(); }
return false;
}
const T& value() const { return handle_.promise().current_value; }
};
// 协程帧小:只有少量局部变量跨挂起点
Generator<int> small_frame() {
int i = 0;
while (true) {
co_yield i++;
}
}
// 协程帧大:大量局部变量跨挂起点
Generator<int> large_frame() {
int a[100] = {}; // 400 字节的数组需要保存到协程帧
int index = 0;
for (int i = 0; i < 100; ++i) {
a[i] = i * i;
}
while (index < 100) {
co_yield a[index++];
}
}
void frame_size_demo() {
// 小帧协程
auto small = small_frame();
for (int i = 0; i < 5 && small.next(); ++i) {
std::cout << small.value() << " ";
}
std::cout << std::endl;
// 大帧协程
auto large = large_frame();
for (int i = 0; i < 5 && large.next(); ++i) {
std::cout << large.value() << " ";
}
std::cout << std::endl;
}
int main() {
std::cout << "=== 传染性演示 ===" << std::endl;
infection_demo();
std::cout << "\n=== 协程帧大小 ===" << std::endl;
frame_size_demo();
return 0;
}适用场景
- 异步 I/O(网络、文件、数据库查询)
- 惰性序列生成(生成器模式)
- 事件驱动编程(GUI、游戏循环)
- 状态机实现(协议解析、工作流引擎)
- 高并发服务器(用协程替代线程处理请求)
常见问题
无栈协程适合所有异步场景吗?
不是。如果你的代码有很深的调用层次且底层需要异步,无栈协程的传染性会迫使你重写大量代码。有栈协程在这种场景下更方便——但它们不是标准的一部分。
HALO 优化可靠吗?
不完全可靠。HALO 是编译器的可选优化,标准不保证它一定生效。在 debug 模式下几乎不会触发。如果你对内存分配敏感,可以通过自定义 operator new 使用内存池。
C++20 协程和线程池怎么配合?
典型模式是:协程挂起时把 coroutine_handle 扔到线程池的任务队列中,线程池里的工作线程调用 handle.resume() 来恢复协程。协程本身不关心在哪个线程上执行。
为什么 C++20 不提供现成的 Task 类型?
C++20 的协程设计理念是"提供机制,不提供策略"。不同的应用场景对协程的行为有不同要求(惰性启动 vs 立即启动、单线程 vs 多线程、异常传播策略等),标准委员会选择先提供底层工具,让库作者和框架设计者来构建适合各自场景的高层类型。
注意事项
- 无栈协程只能在协程函数自身中挂起,不能在子函数中挂起
- 协程帧默认在堆上分配,HALO 优化不是保证的
- 协程的传染性会影响代码架构——设计时需要提前规划
- debug 模式下协程性能可能比 release 差很多(HALO 不生效、没有内联)
- 协程帧的大小取决于跨挂起点的局部变量数量和大小
- 递归协程的每一层都会分配一个独立的协程帧
- 标准没有提供现成的高层协程工具(C++23 才有
std::generator)
编译器支持情况
| 编译器 | 最低支持版本 | HALO 支持 |
|---|---|---|
| GCC | 10.0 | 有限 |
| Clang | 14.0 | 较好 |
| MSVC | 19.28 (VS 2019 16.8) | 有限 |
总结
C++20 的无栈协程通过编译器将协程函数转换为状态机,把跨挂起点的局部变量保存在堆上的协程帧中。相比有栈协程,无栈协程的内存开销更小(只保存必要的变量,而不是整个栈)、切换更快、编译器优化空间更大(HALO 可以消除堆分配)。但无栈协程也有明显的限制:只能在协程函数自身中挂起(不能在子函数中挂起),具有传染性(调用链上的函数都可能需要变成协程),不能用于构造函数/析构函数/main 函数,C++20 标准缺少高层工具类型。理解这些特性和限制,有助于在实际项目中做出合理的架构决策——什么时候用协程、什么时候用线程、什么时候用回调。