一、为什么是 C++23 协程
C++20 引入了协程的语言级基础设施,但标准库只提供了 std::coroutine_handle、std::suspend_always、std::suspend_never 这些“零件”,真正可用的 task、generator、调度器都需要自己实现。C++23 补齐了 std::generator、std::expected、std::move_only_function 等关键组件,让协程从“能写”走向“能用于生产”。
本文的目标是构建一套完整的异步执行体系:
- Task 类型:支持
co_await链式组合、异常传播、取消传播。 - 调度器:单线程事件循环 + 多线程工作窃取两种形态。
- 协程池:预分配协程帧,避免高频创建销毁带来的分配抖动。
- 零栈切换:通过对称转移(symmetric transfer)避免
co_await链上的栈增长与线程切换开销。
阅读前提:了解
co_await/co_yield/co_return的基本语义,知道promise_type与awaiter的职责划分。
二、协程的底层模型回顾
一个协程调用在编译期会被拆成三部分:协程帧(coroutine frame,通常分配在堆上)、promise_type 对象(内嵌在帧中)、以及一个 coroutine_handle(本质是指向帧的裸指针)。
理解下面三个挂起点,是后续所有优化的基础:
| 挂起点 | 触发时机 | 典型用途 |
|---|---|---|
initial_suspend | 协程体执行前 | 惰性启动(lazy task) |
final_suspend | co_return 之后 | 通知等待者、决定帧何时销毁 |
await_suspend | 遇到 co_await 表达式 | 注册回调、切换执行流 |
关键点在于 await_suspend 的返回值:返回 void 表示“挂起并返回调用者”;返回 bool 表示“条件挂起”;返回 coroutine_handle 则表示对称转移——直接把执行权交给另一个协程,而不回到调用者栈帧。
// 对称转移的最小示例:awaiter 返回下一个要恢复的 handle
struct symmetric_awaiter {
std::coroutine_handle<> next;
bool await_ready() const noexcept { return false; }
std::coroutine_handle<> await_suspend(std::coroutine_handle<> /*current*/) noexcept {
// 不返回调用者,直接跳到 next,栈深度不增长
return next;
}
void await_resume() const noexcept {}
};
这就是“零栈切换”的源头:只要 co_await 链上的每个 awaiter 都返回下一个 handle,整条链就在同一个线程栈上以尾调用方式推进,不会出现“每层 await 压一层栈”的问题。
三、设计一个可组合的 Task 类型
先定义最核心的 Task<T>。它需要满足:惰性启动、支持移动、支持异常、支持取消。
#include <coroutine>
#include <exception>
#include <optional>
#include <utility>
template <typename T = void>
class Task {
public:
struct promise_type {
std::optional<T> value;
std::exception_ptr error;
std::coroutine_handle<> continuation{};
Task get_return_object() noexcept {
return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
}
// 惰性启动:创建后不立即执行
std::suspend_always initial_suspend() noexcept { return {}; }
// 结束时把控制权交还给等待者(对称转移)
struct final_awaiter {
bool await_ready() noexcept { return false; }
std::coroutine_handle<> await_suspend(
std::coroutine_handle<promise_type> h) noexcept {
auto cont = h.promise().continuation;
return cont ? cont : std::noop_coroutine();
}
void await_resume() noexcept {}
};
final_awaiter final_suspend() noexcept { return {}; }
void return_value(T v) { value.emplace(std::move(v)); }
void unhandled_exception() { error = std::current_exception(); }
};
using handle_type = std::coroutine_handle<promise_type>;
explicit Task(handle_type h) noexcept : handle_(h) {}
Task(Task&& other) noexcept : handle_(std::exchange(other.handle_, {})) {}
Task& operator=(Task&& other) noexcept {
if (this != &other) {
if (handle_) handle_.destroy();
handle_ = std::exchange(other.handle_, {});
}
return *this;
}
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
~Task() { if (handle_) handle_.destroy(); }
// 让 Task 本身成为 awaiter,实现 task.then 式组合
bool await_ready() const noexcept { return false; }
std::coroutine_handle<> await_suspend(std::coroutine_handle<> caller) noexcept {
handle_.promise().continuation = caller;
return handle_; // 对称转移:直接启动子任务
}
T await_resume() {
if (handle_.promise().error) {
std::rethrow_exception(handle_.promise().error);
}
return std::move(*handle_.promise().value);
}
private:
handle_type handle_;
};
注意 await_suspend 返回 handle_ 而不是 void:调用方协程挂起后,执行流直接进入子任务,子任务结束时通过 final_awaiter 再跳回调用方。整条链没有额外的栈帧增长。
四、调度器:事件循环与工作窃取
Task 只解决“怎么组合”,调度器解决“在哪执行”。先实现一个单线程事件循环,作为所有异步 I/O 的落点。
#include <deque>
#include <mutex>
#include <condition_variable>
#include <thread>
class EventLoop {
public:
void post(std::coroutine_handle<> h) {
{
std::lock_guard<std::mutex> lk(mu_);
queue_.push_back(h);
}
cv_.notify_one();
}
void run() {
for (;;) {
std::coroutine_handle<> h;
{
std::unique_lock<std::mutex> lk(mu_);
cv_.wait(lk, [this] { return !queue_.empty() || stopped_; });
if (queue_.empty() && stopped_) return;
h = queue_.front();
queue_.pop_front();
}
h.resume(); // 恢复协程,内部可能再次 post 自己
}
}
void stop() {
{
std::lock_guard<std::mutex> lk(mu_);
stopped_ = true;
}
cv_.notify_all();
}
private:
std::mutex mu_;
std::condition_variable cv_;
std::deque<std::coroutine_handle<>> queue_;
bool stopped_{false};
};
多线程场景下,把 std::deque 换成每线程一个工作队列 + 全局窃取队列即可。核心约束是:同一个协程帧同一时刻只能被一个线程恢复,因此跨线程投递必须经过队列,而不能直接 resume()。
// 把协程投递到指定 loop 的 awaiter
struct post_to_loop {
EventLoop* loop;
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> h) const { loop->post(h); }
void await_resume() const noexcept {}
};
五、协程池:复用协程帧
高频短任务(如每请求一个协程)会带来大量 operator new/delete。协程池的思路是:为 promise_type 重载 operator new/operator delete,从线程本地空闲链表取帧,归还时放回链表而不是真正释放。
#include <cstddef>
class FramePool {
public:
static FramePool& instance() {
thread_local FramePool pool;
return pool;
}
void* allocate(std::size_t size) {
if (!free_.empty()) {
void* p = free_.back();
free_.pop_back();
return p;
}
return ::operator new(size);
}
void deallocate(void* p) noexcept {
if (free_.size() < kMaxCached) {
free_.push_back(p);
} else {
::operator delete(p);
}
}
private:
static constexpr std::size_t kMaxCached = 256;
std::vector<void*> free_;
};
在 promise_type 中接入:
struct promise_type {
// ... 前面的成员保持不变
static void* operator new(std::size_t size) {
return FramePool::instance().allocate(size);
}
static void operator delete(void* p, std::size_t /*size*/) noexcept {
FramePool::instance().deallocate(p);
}
};
这里有两个必须注意的细节:
- 线程本地池:协程帧的分配与销毁通常发生在同一线程,用
thread_local可以完全避免锁竞争;若跨线程销毁,需要改为全局池或带回收队列。 - 帧大小固定:同一
promise_type的协程帧大小在编译期确定,因此池中元素可以安全互换,无需记录 size。
六、取消传播与异常安全
异步系统里,取消比异常更常见。推荐用 std::stop_token(C++20 引入,C++23 生态已广泛支持)贯穿协程链。
#include <stop_token>
struct cancellation_awaiter {
std::stop_token token;
bool await_ready() const noexcept { return token.stop_requested(); }
void await_suspend(std::coroutine_handle<> h) {
// 注册回调:取消时把协程重新投递到 loop
std::stop_callback cb{token, [h] { /* loop->post(h); */ }};
// 注意:cb 生命周期需覆盖挂起期,实际实现中应存入 promise
}
void await_resume() const {
if (token.stop_requested()) throw std::runtime_error("cancelled");
}
};
异常安全的关键是 final_suspend 必须保证等待者一定被唤醒。上面的 final_awaiter 已经做到:无论正常返回还是异常,都会跳回 continuation,异常在 await_resume 中重新抛出。
七、完整调用链示例
把上面的组件串起来,写一个“并发抓取 + 汇总”的典型场景:
Task<std::string> fetch(std::string url) {
co_await post_to_loop{&global_loop}; // 切到 I/O 线程
// ... 实际异步 I/O,完成后 resume
co_return "response of " + url;
}
Task<void> aggregate() {
auto a = fetch("https://a.example");
auto b = fetch("https://b.example");
// 顺序 await,但每次都是对称转移,栈不增长
std::string ra = co_await std::move(a);
std::string rb = co_await std::move(b);
std::cout << ra << "\n" << rb << "\n";
}
int main() {
auto t = aggregate();
global_loop.post(t.handle()); // 启动
global_loop.run();
}
执行路径:aggregate 挂起 → 对称转移到 fetch(a) → 挂起到 I/O 线程 → I/O 完成投递回 loop → 恢复 fetch(a) → final_suspend 跳回 aggregate → 继续 fetch(b)。整个过程主线程栈深度恒定。
八、性能对比与调优建议
| 方案 | 每任务分配次数 | 上下文切换 | 适用场景 |
|---|---|---|---|
| std::thread per task | 1 线程栈(MB 级) | 内核态切换 | 长任务、CPU 密集 |
| 回调 + 线程池 | 0(但需手动管理生命周期) | 队列投递 | 成熟 I/O 框架 |
| 协程(无池) | 1 次堆分配 | 用户态对称转移 | 中等频率任务 |
| 协程 + 帧池 | 摊销后接近 0 | 用户态对称转移 | 高频短任务 |
调优建议:
- 先用
perf或tracy确认瓶颈在分配还是调度,不要盲目上池。 - 帧池容量按 P99 并发量设置,过大会浪费内存,过小会退化为频繁
operator new。 - 避免在
await_suspend中做重活,它运行在调用者栈上,会直接放大延迟。 - 跨线程恢复务必走队列,直接
resume()是数据竞争的常见来源。
九、小结
C++23 协程的生产可用性,取决于三件事:一个语义正确的 Task、一个边界清晰的调度器、以及一个能压住分配开销的帧池。对称转移是贯穿始终的主线——它让 co_await 链以尾调用方式推进,把“协程切换”的成本压到接近函数调用。
下一步可以继续深入:std::generator 的惰性序列、基于 io_uring 的完成队列集成、以及协程与 std::execution(P2300)sender/receiver 模型的对接。
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/FJ39SfgYS/article/details/171054593



