C++ 协程：用同步风格写出清晰可靠的异步逻辑

在现代高性能服务开发中，异步编程已成为处理高并发 I/O 的标准范式。然而，传统基于回调或 std::future 的异步模型常导致代码嵌套过深、错误处理分散、状态管理复杂，形成典型的“回调地狱”。C++20 引入的协程（Coroutines）机制，为这一困境提供了根本性解法——它允许开发者以接近同步代码的线性结构表达异步流程，同时保持零栈切换开销与完全可控的执行调度。本文将系统阐述 C++ 协程如何简化异步逻辑，并通过可运行示例展示其在真实场景中的表达力与可靠性。

协程不是线程：理解核心抽象

协程是可挂起与恢复的函数，其执行不绑定操作系统线程。一次协程调用不会阻塞线程，而是在等待异步操作完成时主动让出控制权，由调度器决定何时恢复。这种协作式并发模型避免了线程上下文切换成本，也消除了竞态条件风险（只要不共享可变状态）。C++ 协程的关键在于三个新关键字：co_await、co_yield 和 co_return，以及一套可定制的协程框架接口（promise_type、awaiter 等）。

要使一个函数成为协程，只需在其函数体中使用上述任一关键字。编译器将自动将其重写为状态机，并生成相应协程帧（coroutine frame）用于保存局部变量与挂起点。

从回调到协程：一个 HTTP 请求示例

假设我们需要实现一个异步 HTTP 客户端请求函数。传统回调方式如下：

// 伪代码：回调风格（非标准，仅示意结构）
void http_get_async(const std::string& url,
                    std::function<void(std::string)> on_success,
                    std::function<void(std::string)> on_error) {
    // 启动网络请求，完成后调用对应回调
}

调用时需层层嵌套：

http_get_async("https://api.example.com/users", 
    [&](std::string data) {
        parse_users(data, [&](auto users) {
            for (const auto& u : users) {
                http_get_async("https://api.example.com/profile/" + u.id,
                    [&](std::string profile) { /* ... */ },
                    [&](std::string err) { /* ... */ });
            }
        });
    },
    [](std::string err) { /* ... */ });

逻辑支离破碎，异常难以统一捕获，资源清理困难。

使用协程后，等效逻辑变得直观：

#include <coroutine>
#include <string>
#include <memory>

// 简化的协程返回类型（实际项目中建议使用成熟库如 cppcoro 或 libunifex）
struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

// 模拟可等待对象：代表一个异步 HTTP 请求
struct HttpGetAwaiter {
    std::string url;
    bool await_ready() const noexcept { return false; }
    void await_suspend(std::coroutine_handle<> h) {
        // 实际中此处提交请求到 IO 多路复用器（如 epoll/kqueue）
        // 并注册回调：当响应就绪时调用 h.resume()
        simulate_io_submit(url, h);
    }
    std::string await_resume() {
        // 返回模拟响应体
        return "{\"id\":\"u1\",\"name\":\"Alice\"}";
    }
};

HttpGetAwaiter http_get(const std::string& url) {
    return {url};
}

// 协程函数：语法同步，语义异步
Task fetch_user_profile() {
    try {
        auto user_json = co_await http_get("https://api.example.com/users/1");
        // 解析 JSON（同步操作）
        auto user_id = parse_id_from_json(user_json);
        auto profile_json = co_await http_get(
            "https://api.example.com/profile/" + user_id);
        process_profile(profile_json);
    } catch (const std::exception& e) {
        log_error("Failed to fetch profile: ", e.what());
    }
}

注意：co_await 表达式暂停当前协程，但线程继续执行其他任务；当 http_get 关联的 I/O 就绪，调度器调用 await_suspend 中保存的句柄恢复该协程。整个过程无栈复制、无线程阻塞，且 try/catch 可自然捕获异步操作抛出的异常。

错误传播与资源安全

协程天然支持 RAII。局部对象的析构函数在协程销毁时（无论因完成或异常）被正确调用：

Task upload_file(const std::string& path) {
    auto file = std::make_unique<FileHandle>(path); // RAII 资源
    co_await file->open_async();                     // 可能抛异常

    auto buffer = std::make_unique<char[]>(4096);
    while (auto n = co_await file->read_async(buffer.get(), 4096)) {
        co_await network_send_async(buffer.get(), n);
    }
    // file 和 buffer 在此自动释放，即使中间发生异常
}

对比回调风格中需手动管理资源生命周期，协程显著降低内存泄漏与资源泄露风险。

组合多个异步操作

协程支持 co_await 多个异步操作，并轻松实现并行与竞速模式。例如，同时请求两个微服务并取最快结果：

Task fetch_fastest() {
    auto req_a = http_get("https://service-a/api");
    auto req_b = http_get("https://service-b/api");

    // 竞速：谁先完成就用谁
    auto [result, winner] = co_await race(req_a, req_b);
    if (winner == 0) {
        handle_service_a_result(result);
    } else {
        handle_service_b_result(result);
    }
}

其中 race 是一个通用协程组合子，内部启动两个子协程并监听其完成信号。这种组合能力远超 std::future::wait_any 的笨重接口。

调度器与执行上下文

协程本身不指定调度策略，这赋予了极大灵活性。你可以构建专用调度器：

• 线程池调度器：将协程分配给工作线程执行 CPU 密集型任务；
• IO 调度器：集成 epoll/io_uring，专司异步文件与网络操作；
• UI 调度器：确保所有协程恢复都在主线程执行，避免 Qt/Win32 跨线程访问违规。

关键在于 await_suspend 中如何传递 std::coroutine_handle。例如，IO 调度器可将其存入就绪队列，待事件循环检测到 socket 可读时批量恢复。

实践建议与注意事项

1. 避免在协程中执行阻塞调用：如 std::this_thread::sleep_for 或 fread，否则会阻塞整个线程。应使用 co_await sleep_for_async(...) 等异步替代品。

2. 谨慎传递 this 指针：协程可能跨线程恢复，若 this 指向栈对象或已被销毁的对象，将引发未定义行为。优先使用 std::shared_ptr 管理长生命周期对象。

3. 启用编译器警告：GCC/Clang 提供 -Wcoroutine 检测常见误用，如在非协程函数中使用 co_await。

4. 性能剖析不可少：虽然协程开销极小，但不当的 co_await 频率（如在 tight loop 中）仍可能影响吞吐。建议结合 perf 或 vtune 分析协程切换热点。

结语：回归编程本质

C++ 协程并未改变异步的本质——它依然是事件驱动、非阻塞、基于回调的底层机制。但它彻底改变了程序员的思维模型：我们不再需要在头脑中手动展开状态机，不再被回调嵌套所困，也不必在 future.then().then().then() 的链式调用中迷失控制流。协程让代码忠实反映业务意图，将“做什么”与“何时做”清晰分离。

对于追求可靠、可维护与高性能的 C++ 服务端开发而言，协程不是锦上添花的新玩具，而是重构异步编程范式的基石。从今天开始，在新模块中尝试协程吧——用同步的优雅，驾驭异步的力量。