我要见SA姐1头像

C++23 协程全栈实战:从异步任务调度到协程池的零栈切换实现

一、为什么是 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_suspendco_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);
    }
};

这里有两个必须注意的细节:

  1. 线程本地池:协程帧的分配与销毁通常发生在同一线程,用 thread_local 可以完全避免锁竞争;若跨线程销毁,需要改为全局池或带回收队列。
  2. 帧大小固定:同一 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 task1 线程栈(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

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--