深入理解C++20中的协程：设计模式与实践

作者

协程（Coroutines）是C++20标准中引入的重要特性，旨在简化异步编程与状态机的实现。本文从设计模式视角出发，结合实际示例，剖析协程在现代C++项目中的应用与注意事项。

1. 协程的基本概念

协程是一种可暂停与恢复的函数，它们在运行过程中可以多次挂起，并在之后继续执行。相较于传统的回调或线程，协程能保持代码的顺序性与可读性，同时减少上下文切换成本。

C++协程主要由三大关键字支撑：

  • co_await：挂起协程，等待一个可等待对象完成。
  • co_yield：生成一个值并挂起，允许调用方消费。
  • co_return：终止协程并返回结果。

2. 协程的返回类型

协程的返回类型决定了其行为模式。常见的返回类型包括：

  • `std::future `：适用于异步任务，等待结束后得到结果。
  • `std::generator `（在标准库中尚未正式引入）：支持迭代器式消费。
  • 自定义的 Task / Awaitable 结构：用于更细粒度的控制。

示例：自定义异步任务

template<typename T>
struct AsyncTask {
    struct promise_type {
        std::promise <T> p;
        AsyncTask get_return_object() { return AsyncTask{p.get_future()}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_value(T value) { p.set_value(value); }
        void unhandled_exception() { p.set_exception(std::current_exception()); }
    };

    std::future <T> fut;
    explicit AsyncTask(std::future <T> f) : fut(std::move(f)) {}
    T get() { return fut.get(); }
};

3. 协程与设计模式

3.1 观察者模式

协程可以天然支持事件驱动的观察者模式。通过 co_await 等待事件对象，协程会在事件触发时恢复执行。

struct Event {
    std::coroutine_handle<> waiting;
    void trigger() { if (waiting) waiting.resume(); }
};

Task <void> observer(Event& ev) {
    co_await ev; // 等待事件
    std::cout << "Event triggered!\n";
}

3.2 状态机模式

传统状态机实现往往需要显式维护状态变量。协程的挂起点天然对应状态，省去手动管理。

Task <void> stateMachine() {
    std::cout << "State A\n";
    co_await std::chrono::seconds(1);
    std::cout << "State B\n";
    co_await std::chrono::seconds(1);
    std::cout << "State C\n";
}

4. 关键技术细节

4.1 资源管理

协程的生命周期与 promise_type 对象相关，需确保在挂起前后资源的安全。使用 std::shared_ptr 或自定义 finally 机制可避免内存泄漏。

4.2 与线程池的结合

在多线程环境下，可将协程提交给线程池执行，利用 co_await 与 std::future 实现异步调度。

ThreadPool pool;
Task <int> compute(int x) {
    int res = heavyComputation(x);
    co_return res;
}

void submitTask() {
    auto fut = pool.submit(compute(42));
    std::cout << "Result: " << fut.get() << '\n';
}

4.3 错误传播

协程内部异常会通过 unhandled_exception 传递给外部 std::future。可在外部捕获：

try {
    int val = compute(5).get();
} catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << '\n';
}

5. 性能考量

  • 栈开销：协程在挂起时会将调用帧保存在堆上，避免深层递归导致栈溢出。
  • 上下文切换：协程切换比线程轻量，但在高并发场景需注意协程调度器的实现。
  • 缓存友好：协程帧可连续分配，提升数据局部性。

6. 典型应用场景

  1. 网络 I/O：使用 co_await 等待 socket 可读/可写事件。
  2. 游戏循环：将游戏逻辑拆分为协程，保持代码顺序性。
  3. 微服务：异步调用链通过协程实现无回调编程。

7. 结语

C++20 的协程为异步编程提供了强大而简洁的工具。通过结合设计模式与实际案例，开发者可以显著提升代码可读性、可维护性与性能。随着编译器与标准库的成熟，协程将成为现代 C++ 开发不可或缺的一环。

发表评论