C++20 中的协程（coroutines）如何简化异步编程？

作者

协程（coroutines）是 C++20 标准引入的一项强大特性，旨在让异步编程更接近同步代码的书写风格，从而显著降低复杂度。下面我们从概念、实现机制、使用场景以及实际代码示例四个方面来系统解析协程如何简化异步编程。

一、协程的基本概念

  • 协程是一种能在执行过程中暂停并在之后恢复的函数。与普通函数不同，它们可以在任意位置“挂起”（co_await、co_yield、co_return），并保持其局部状态，等到再次调用时从挂起点继续执行。
  • 异步操作可以被包装为协程，调用方无需显式管理回调链，整个流程看起来像同步代码。

二、协程实现机制

C++20 的协程实现基于协程生成器（std::generator）、任务类型（std::future/std::promise或自定义）以及 协程句柄（std::coroutine_handle）共同工作：

  1. 协程函数返回一个自定义类型（如 `Task `），其内部持有 `std::coroutine_handle`，负责管理协程状态。
  2. co_await 触发协程挂起，控制权转移到等待的 Awaitable 对象。该对象提供 await_ready()、await_suspend()、await_resume() 三个成员，决定是否挂起、挂起时的行为以及恢复时的返回值。
  3. co_yield 用于生成器，用于返回一系列值；co_return 用于返回最终结果或抛出异常。

通过这些机制，协程能够在需要等待 I/O、网络或定时器时挂起自身，而不占用线程资源。

三、协程简化异步编程的核心优势

传统异步写法 协程写法 主要区别
回调函数嵌套 直线代码 避免“回调地狱”
需要显式状态机 自动恢复 省去手动维护状态
错误传播通过错误码或异常链 通过异常或 co_return 统一异常处理
线程阻塞或线程池 非阻塞挂起 资源利用率更高

举例来说，使用协程可以将异步网络请求的流程写成：

Task <int> fetch_data() {
    auto response = co_await http_client.get("https://api.example.com/data");
    if (!response.ok())
        throw std::runtime_error("HTTP error");
    co_return std::stoi(response.body());
}

这段代码与同步版本几乎一样，省去了回调链、状态机、错误码检查等琐事。

四、实战案例：异步文件读取

下面给出一个完整的协程实现，用于异步读取文件并返回内容。

#include <iostream>
#include <fstream>
#include <coroutine>
#include <string>
#include <future>
#include <thread>
#include <chrono>

// 简单的 Awaitable：等待指定毫秒后恢复
struct sleep_for {
    std::chrono::milliseconds ms;
    bool await_ready() const noexcept { return ms.count() == 0; }
    void await_suspend(std::coroutine_handle<> h) const {
        std::thread([h, ms = ms]() {
            std::this_thread::sleep_for(ms);
            h.resume();
        }).detach();
    }
    void await_resume() const noexcept {}
};

// Task 只支持返回值，不支持异常传播（简化示例）
template<typename T>
struct Task {
    struct promise_type {
        T value;
        Task get_return_object() { return Task{std::coroutine_handle <promise_type>::from_promise(*this)}; }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_value(T v) { value = std::move(v); }
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle <promise_type> h;
    Task(std::coroutine_handle <promise_type> h_) : h(h_) {}
    ~Task() { if (h) h.destroy(); }
    T get() { return h.promise().value; }
};

Task<std::string> async_read_file(const std::string& path) {
    // 模拟异步延迟
    co_await sleep_for{std::chrono::milliseconds(100)};

    std::ifstream ifs(path, std::ios::binary);
    if (!ifs) throw std::runtime_error("Cannot open file");

    std::string content((std::istreambuf_iterator <char>(ifs)),
                         std::istreambuf_iterator <char>());
    co_return std::move(content);
}

int main() {
    auto task = async_read_file("test.txt");
    std::string data = task.get();  // 这里阻塞直到协程完成
    std::cout << "文件内容长度: " << data.size() << '\n';
}

说明

  • sleep_for 作为一个 Awaitable，演示如何在协程中挂起并在指定时间后恢复。实际上文件 I/O 需要使用非阻塞文件 API（如 ASIO）来真正实现异步读取。
  • `Task ` 是一个极简的协程包装器，负责保存协程句柄和结果。真实项目中可使用 `std::future`、`std::experimental::generator` 或第三方库（Boost.Coroutine2、cppcoro）来增强功能。

五、协程生态与实践建议

  1. 库支持：Boost.Asio 在 1.70 之后已支持协程，让你可以直接在异步网络 I/O 中使用 co_await。此外，cppcoro 提供了 task、generator、channel 等实用工具。
  2. 错误处理：协程函数内部可以抛出异常，调用方通过 try/catch 捕获。若返回 `std::future `，异常会被包装在 future 中。
  3. 性能：协程本质上是状态机，生成的机器体积比手写回调链更小；但切换成本略高。对于高并发 I/O 场景，协程往往能更好地利用线程资源。

六、总结

C++20 的协程为异步编程提供了几乎同步的语义，降低了回调嵌套、状态机编写以及错误处理的复杂度。通过协程，我们可以用更直观、更易维护的代码实现复杂的异步逻辑，从而提升代码质量与开发效率。随着生态成熟与编译器优化，协程将成为 C++ 现代化异步编程的核心工具。

发表评论