掌握C++20 中的协程：从基本原理到实践应用

作者

C++20 为语言引入了协程（Coroutines）这一强大特性，使得异步编程与并发处理更加直观与高效。本文将从协程的基本原理讲起，逐步演示如何在实际项目中使用协程解决常见的异步任务，并给出常见陷阱与最佳实践建议。

1. 协程到底是什么？

协程是可以暂停与恢复执行的函数，它在执行过程中可以挂起自身并将控制权交还给调用者，然后在需要时再恢复继续执行。C++ 的协程实现借鉴了“生成器”（generator）与“异步函数”（async function）的概念，内部通过生成状态机来管理挂起点。

核心关键字包括：

  • co_await：等待一个异步操作完成。
  • co_yield：生成一个值给调用者。
  • co_return：终止协程并返回结果。

C++ 协程的实现依赖于标准库中的 std::coroutine_handle、std::suspend_always、std::suspend_never 等模板，开发者可以根据需要自定义挂起策略。

2. 协程的典型使用场景

  1. 异步 I/O：利用协程将非阻塞 I/O 逻辑写成同步样式，显著提升代码可读性。
  2. 生成器模式：如文件行读取、网络消息帧迭代等场景，co_yield 能够一次返回一个结果，避免一次性把所有数据读入内存。
  3. 并发流控制：在多线程环境中，用协程实现轻量级任务切换，减少线程上下文切换开销。

3. 从代码看协程的工作流程

下面给出一个最小可运行示例，展示协程如何与 std::future 配合完成异步计算。

#include <coroutine>
#include <future>
#include <iostream>
#include <thread>

struct AsyncTask {
    struct promise_type {
        std::future <int> get_future() {
            return std::move(handle_.get_future());
        }

        int return_value_;
        std::promise <int> promise_;
        std::coroutine_handle <promise_type> handle_;

        AsyncTask get_return_object() {
            handle_ = std::coroutine_handle <promise_type>::from_promise(*this);
            return {handle_};
        }

        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }

        void return_value(int v) { promise_.set_value(v); }
        void unhandled_exception() { promise_.set_exception(std::current_exception()); }
    };

    AsyncTask(std::coroutine_handle <promise_type> h) : handle_(h) {}
    ~AsyncTask() { if (handle_) handle_.destroy(); }

    std::future <int> get_future() { return handle_.promise().get_future(); }

private:
    std::coroutine_handle <promise_type> handle_;
};

AsyncTask compute_async(int x) {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟耗时
    co_return x * x;
}

int main() {
    auto task = compute_async(5);
    auto fut = task.get_future();

    std::cout << "异步计算开始...\n";
    std::cout << "结果: " << fut.get() << std::endl;
}

此例中，compute_async 是一个协程函数，内部通过 co_return 返回最终值。主线程通过 std::future 进行同步等待，体现了协程与传统异步机制的无缝结合。

4. 协程与线程池的结合

在高并发网络服务中，常见做法是将协程与线程池配合使用，核心思路是：线程池执行 I/O 完成后，唤醒对应协程继续处理业务逻辑。示例框架（伪代码）：

class Reactor {
public:
    void run() {
        while (running_) {
            auto events = poller_->wait();
            for (auto& ev : events) {
                if (ev.is_readable) {
                    auto co_handle = get_coroutine(ev.socket);
                    co_handle.resume(); // 恢复协程
                }
            }
        }
    }
};

此模式将 I/O 事件驱动与协程挂起/恢复机制结合，既保持了事件循环的单线程优势，又实现了异步协程的并发效果。

5. 常见陷阱与调试技巧

陷阱 说明 解决方案
co_await 之后忘记 co_yield 或 co_return 协程状态机未完成，导致悬挂 确认每个挂起点都有对应的恢复或结束
std::future 与协程混用导致死锁 future.get() 在协程内部等待自身完成 使用 co_await 等待 std::future 或改用 std::shared_future
资源泄漏：std::coroutine_handle 未销毁 协程结束后没有显式销毁 在 promise_type::final_suspend 中调用 handle_.destroy()
性能不如预期 协程状态机过大 通过 co_yield 控制返回粒度，或使用 std::suspend_always/std::suspend_never 优化挂起策略

调试时可以使用编译器自带的协程可视化工具，例如 Clang 的 -fsanitize=undefined 或 Visual Studio 的 “协程状态机” 视图，帮助定位挂起点与恢复点的执行路径。

6. 总结

  • 协程是异步编程的语法糖：用同步的写法实现异步逻辑，极大提升代码可读性与维护性。
  • C++20 协程与标准库：通过 std::future、std::promise、std::coroutine_handle 等配合使用，构建完整的异步框架。
  • 最佳实践：控制协程的生命周期、合理使用挂起策略、与线程池/事件循环结合，充分发挥协程优势。

掌握了这些知识，你就能在自己的项目中自如地使用 C++ 协程，实现高性能、低耦合的异步系统。祝编码愉快！

发表评论