协程 co_await 挂起点分析
面试考点
co_await 是 C++20 协程的核心机制。面试官通过这道题考察你是否理解 co_await 的展开过程:编译器如何调用 awaiter 的三个函数(await_ready、await_suspend、await_resume),以及挂起点的状态保存和恢复。
核心概念
co_await expr 不是简单的函数调用,编译器会将它展开为一系列步骤:先获取 awaiter 对象,调用 await_ready() 判断是否需要挂起,如果需要挂起则调用 await_suspend() 并保存状态,恢复时调用 await_resume() 获取结果。每个 co_await 都是一个潜在的挂起点。
co_await 展开过程
| 步骤 | 动作 | 说明 |
|---|---|---|
| 获取 awaiter | 调用 operator co_await 或直接使用表达式 | 得到 awaiter 对象 |
| await_ready() | 返回 bool | true 则跳过挂起,直接执行 await_resume |
| await_suspend(handle) | 保存协程状态 | 返回 void/bool/coroutine_handle |
| 挂起 | 控制权返回调用者 | 协程帧保存在堆上 |
| 恢复 | handle.resume() 被调用 | 从挂起点继续 |
| await_resume() | 获取 co_await 的结果 | 可以返回任意类型 |
基本示例
#include <iostream>
#include <coroutine>
#include <string>
#include <thread>
#include <chrono>
// ============================
// 示例1:co_await 的编译器展开
// ============================
/*
用户代码:
co_await some_awaitable;
编译器展开为(伪代码):
{
auto&& awaitable = some_awaitable;
auto&& awaiter = get_awaiter(awaitable); // 可能调用 operator co_await
if (!awaiter.await_ready()) {
// 保存协程状态到帧
<suspend-coroutine>
// 调用 await_suspend
// 根据返回类型有三种行为:
awaiter.await_suspend(coroutine_handle);
// 控制权返回给调用者/恢复者
<return-to-caller-or-resumer>
}
// 恢复后(或没挂起时)执行
auto result = awaiter.await_resume();
// result 就是 co_await 表达式的值
}
*/
// ============================
// 示例2:自定义 awaiter
// ============================
// 一个简单的 awaiter,演示三个函数的调用时机
struct TracingAwaiter {
const char* name;
TracingAwaiter(const char* n) : name(n) {}
// 第一步:是否需要挂起?
bool await_ready() const noexcept {
std::cout << name << "::await_ready() 被调用" << std::endl;
return false; // false = 需要挂起
}
// 第二步:挂起时的操作
void await_suspend(std::coroutine_handle<> handle) const noexcept {
std::cout << name << "::await_suspend() 被调用" << std::endl;
// 这里可以:
// 1. 什么都不做(协程暂停,等待外部 resume)
// 2. 把 handle 存起来,稍后恢复
// 3. 立即调用 handle.resume()(等于没挂起)
// 4. 调用另一个协程的 handle.resume()
}
// 第三步:恢复时获取结果
int await_resume() const noexcept {
std::cout << name << "::await_resume() 被调用" << std::endl;
return 42; // co_await 表达式的值
}
};
// 简单的协程返回类型
struct SimpleTask {
struct promise_type {
SimpleTask get_return_object() {
return SimpleTask{
std::coroutine_handle<promise_type>::from_promise(*this)
};
}
std::suspend_never initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> handle;
~SimpleTask() { if (handle) handle.destroy(); }
SimpleTask(std::coroutine_handle<promise_type> h) : handle(h) {}
SimpleTask(SimpleTask&& o) noexcept : handle(o.handle) { o.handle = nullptr; }
SimpleTask(const SimpleTask&) = delete;
void resume() { if (handle && !handle.done()) handle.resume(); }
};
SimpleTask tracing_coroutine() {
std::cout << "协程开始" << std::endl;
// 第一个挂起点
int result = co_await TracingAwaiter("Awaiter1");
std::cout << "Awaiter1 返回: " << result << std::endl;
// 第二个挂起点
co_await TracingAwaiter("Awaiter2");
std::cout << "协程结束" << std::endl;
}
void tracing_demo() {
auto task = tracing_coroutine();
// 输出:协程开始 → Awaiter1::await_ready → Awaiter1::await_suspend
// 协程在第一个 co_await 处挂起
std::cout << "--- 第一次 resume ---" << std::endl;
task.resume();
// 输出:Awaiter1::await_resume → 返回 42 → Awaiter2::await_ready → Awaiter2::await_suspend
std::cout << "--- 第二次 resume ---" << std::endl;
task.resume();
// 输出:Awaiter2::await_resume → 协程结束
}
// ============================
// 示例3:await_suspend 的三种返回类型
// ============================
// 返回 void:无条件挂起
struct SuspendAlways {
bool await_ready() { return false; }
void await_suspend(std::coroutine_handle<>) {} // 无条件挂起
void await_resume() {}
};
// 返回 bool:条件挂起
struct ConditionalSuspend {
bool should_suspend;
bool await_ready() { return false; }
bool await_suspend(std::coroutine_handle<>) {
// 返回 true:挂起
// 返回 false:不挂起,立即恢复
return should_suspend;
}
void await_resume() {}
};
// 返回 coroutine_handle:对称转移(symmetric transfer)
struct SymmetricTransfer {
std::coroutine_handle<> target;
bool await_ready() { return false; }
std::coroutine_handle<> await_suspend(std::coroutine_handle<>) {
// 返回另一个协程的 handle,控制权转移给它
// 避免了栈溢出(不递归调用 resume)
if (target) return target;
return std::noop_coroutine(); // 没有目标时返回调用者
}
void await_resume() {}
};
// ============================
// 示例4:await_ready 的优化作用
// ============================
// 模拟异步操作:可能已经完成
struct AsyncRead {
bool completed_ = false;
std::string data_;
bool await_ready() const noexcept {
// 如果数据已经就绪,跳过挂起(性能优化)
return completed_;
}
void await_suspend(std::coroutine_handle<> handle) noexcept {
// 模拟异步操作
// 实际中会注册回调,操作完成后调用 handle.resume()
data_ = "async data";
completed_ = true;
handle.resume(); // 模拟立即完成
}
std::string await_resume() {
return std::move(data_);
}
};
// ============================
// 示例5:co_await 表达式的值
// ============================
struct ValueAwaiter {
int value;
bool await_ready() { return true; } // 不挂起
void await_suspend(std::coroutine_handle<>) {}
int await_resume() { return value; } // 返回值就是 co_await 的结果
};
SimpleTask value_coroutine() {
// co_await 可以有返回值
int a = co_await ValueAwaiter{10};
int b = co_await ValueAwaiter{20};
std::cout << "a + b = " << a + b << std::endl;
}
// ============================
// 示例6:标准库的 awaiter
// ============================
/*
std::suspend_always:
await_ready() → false (总是挂起)
await_suspend() → void (无条件挂起)
await_resume() → void (没有返回值)
std::suspend_never:
await_ready() → true (从不挂起)
await_suspend() → void
await_resume() → void
std::noop_coroutine_handle:
resume() 什么都不做
用于 await_suspend 返回时表示"返回调用者"
*/
// ============================
// 示例7:operator co_await 定制
// ============================
struct MyAwaitable {
int data;
// 定义 operator co_await 来提供自定义 awaiter
auto operator co_await() {
struct Awaiter {
int& data;
bool await_ready() { return false; }
void await_suspend(std::coroutine_handle<>) {}
int await_resume() { return data * 2; }
};
return Awaiter{data};
}
};
SimpleTask operator_demo_coro() {
MyAwaitable obj{21};
int result = co_await obj; // 调用 obj.operator co_await()
std::cout << "operator co_await 结果: " << result << std::endl; // 42
}
int main() {
std::cout << "=== 挂起点追踪 ===" << std::endl;
tracing_demo();
std::cout << "\n=== 值传递 ===" << std::endl;
{
auto task = value_coroutine();
}
std::cout << "\n=== operator co_await ===" << std::endl;
{
auto task = operator_demo_coro();
task.resume();
}
return 0;
}await_suspend 返回类型的行为
| 返回类型 | 行为 |
|---|---|
| void | 无条件挂起,控制权返回给 resume 的调用者 |
| bool | true 则挂起,false 则立即恢复(不挂起) |
| coroutine_handle<> | 对称转移:恢复返回的 handle 对应的协程 |
获取 awaiter 的查找顺序
| 优先级 | 查找方式 |
|---|---|
| 最高 | promise.await_transform(expr),然后对结果执行下面的查找 |
| 中 | expr.operator co_await()(成员函数) |
| 中 | operator co_await(expr)(自由函数,通过 ADL) |
| 最低 | 直接使用 expr 作为 awaiter |
常见问题
await_ready 返回 true 和不写 co_await 有什么区别?
await_ready 返回 true 时仍然会调用 await_resume(),可以获取返回值。只是跳过了 await_suspend,不会挂起协程。这是一种性能优化:当异步操作已经同步完成时,避免不必要的挂起和恢复开销。
对称转移(symmetric transfer)解决什么问题?
如果 await_suspend 内部直接调用 handle.resume(),每次恢复都会增加调用栈深度,大量协程链式恢复会导致栈溢出。对称转移通过返回 coroutine_handle,让编译器在不增加栈深度的情况下切换到另一个协程(尾调用优化)。
co_await 可以出现在什么位置?
co_await 可以出现在协程函数体的任何表达式位置,包括 if 条件、for 循环、函数参数等。但不能出现在 catch 块、constexpr 函数、构造函数/析构函数中。
适用场景
- 异步 I/O(网络读写、文件操作)
- 定时器等待
- 协程间的同步(信号量、事件)
- 惰性生成器(co_yield 内部也是 co_await)
注意事项
- await_suspend 中如果立即 resume 当前 handle,要小心递归
- final_suspend 的 awaiter 不能抛异常(声明为 noexcept)
- await_suspend 中协程已经挂起,访问局部变量需要通过 handle
- 自定义 awaiter 的析构时机要注意
- 对称转移需要编译器支持尾调用优化
总结
co_await 是 C++20 协程的核心,编译器将其展开为 await_ready → await_suspend → await_resume 三步调用。await_ready 决定是否需要挂起(性能优化),await_suspend 处理挂起逻辑(三种返回类型对应不同行为),await_resume 提供 co_await 表达式的值。面试中要能画出 co_await 的展开流程、解释三种 await_suspend 返回类型的区别、以及对称转移解决栈溢出的原理。