为什么 C++20 的 coroutines 与传统回调相比更适合异步编程？

作者

在 C++20 之前，异步编程常常使用回调函数、状态机或第三方库（如 Boost.Asio）来处理非阻塞 I/O。虽然这些方法可行，但它们通常导致代码难以阅读、维护成本高，并且容易出现“回调地狱”。C++20 引入的协程（coroutines）彻底改变了这一局面，为异步编程提供了更直观、更高效的解决方案。

1. 协程的基本概念

协程是能够在多个点暂停和恢复的函数。相比传统函数，协程在暂停时会保存其执行状态，并在恢复时继续执行，而不需要手动管理状态机。C++20 对协程的支持主要通过以下几个关键词实现：

  • co_await：等待一个 awaitable 对象完成。
  • co_yield：在协程内部产生一个值。
  • co_return：返回协程的最终结果。

协程的实现细节被封装在 std::coroutine_handle、std::promise 和 std::future 等标准库组件中，程序员可以专注于业务逻辑，而无需关心协程的低层实现。

2. 协程 vs 回调的比较

维度 回调 协程
可读性 嵌套层级多，逻辑分散 像普通顺序代码，易读易维护
错误处理 需要手动在每个回调中捕获异常 通过异常传播，错误链自然
状态管理 需手动维护状态机 状态自动保存，代码简洁
性能 频繁堆分配、上下文切换 协程使用栈帧，开销更小
适配性 与旧 API 集成困难 与同步代码无缝切换

从上表可以看出，协程在可读性、错误处理、状态管理以及性能方面都有显著优势。

3. 实际使用示例

下面展示一个使用 C++20 协程完成文件读取的简易示例。假设我们使用 std::experimental::filesystem 读取目录，并用 std::ifstream 读取文件内容。

#include <iostream>
#include <fstream>
#include <string>
#include <filesystem>
#include <coroutine>
#include <future>

namespace fs = std::filesystem;

// 简单的 awaitable 类型，用于模拟异步 I/O
template<typename T>
struct AsyncRead {
    std::string filename;
    T result{};
    bool ready = false;

    bool await_ready() const noexcept { return ready; }
    void await_suspend(std::coroutine_handle<> h) {
        // 在独立线程中读取文件
        std::thread([this, h](){
            std::ifstream file(filename);
            std::string content((std::istreambuf_iterator <char>(file)),
                                std::istreambuf_iterator <char>());
            result = std::move(content);
            ready = true;
            h.resume(); // 恢复协程
        }).detach();
    }
    T await_resume() { return result; }
};

std::future<std::string> read_file_async(const std::string& path) {
    co_return co_await AsyncRead<std::string>{path};
}

int main() {
    auto fut = read_file_async("example.txt");
    std::cout << "文件内容:\n" << fut.get() << std::endl;
    return 0;
}

此示例演示了：

  1. 如何创建一个可等待的对象 AsyncRead。
  2. 在 await_suspend 中启动异步工作（在新线程中读取文件）。
  3. 在主协程中使用 co_await 等待结果。
  4. co_return 将最终结果包装为 std::future，方便与同步代码混合使用。

4. 与 Boost.Asio 的协作

Boost.Asio 已经在 C++20 之前就支持异步 I/O。自从 C++20 之后，Boost.Asio 通过 co_spawn 和 awaitable 类型进一步简化了协程编程。示例代码：

#include <boost/asio.hpp>
#include <boost/asio/awaitable.hpp>
#include <boost/asio/use_awaitable.hpp>

boost::asio::awaitable <void> async_echo(boost::asio::ip::tcp::socket sock) {
    char data[1024];
    std::size_t n = co_await sock.async_read_some(boost::asio::buffer(data),
                                                  boost::asio::use_awaitable);
    co_await sock.async_write_some(boost::asio::buffer(data, n),
                                   boost::asio::use_awaitable);
    co_return;
}

int main() {
    boost::asio::io_context ctx;
    boost::asio::ip::tcp::acceptor acceptor(ctx,
        boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 12345));
    boost::asio::spawn(ctx, [&](boost::asio::yield_context yield){
        for (;;) {
            boost::asio::ip::tcp::socket sock(ctx);
            acceptor.accept(sock, yield);
            boost::asio::spawn(ctx, std::bind(async_echo, std::move(sock)),
                               boost::asio::detached);
        }
    });
    ctx.run();
}

在此代码中：

  • async_echo 是一个协程，使用 co_await 等待读写操作。
  • boost::asio::spawn 用来启动协程。
  • boost::asio::use_awaitable 将 Boost.Asio 的异步操作包装为 awaitable 对象，直接在协程中使用。

5. 性能与资源利用

协程相对于回调的性能优势主要体现在：

  • 栈帧共享：协程在同一线程中继续执行，避免了线程切换。
  • 延迟分配：协程的状态仅在需要时才分配（如使用 co_await 时）。
  • 避免回调链：减少了多层嵌套回调导致的堆栈膨胀。

实际测量显示，使用协程的网络 I/O 程序在相同负载下往往比使用传统回调方式快 10%~20%。

6. 未来展望

C++20 的协程仍在不断发展。未来的 C++23、C++26 版本将进一步完善标准库中的协程工具，例如：

  • 更丰富的 std::generator、std::task 等抽象。
  • 与 std::chrono、std::ranges 等结合的高级用法。
  • 更完善的跨平台异步 I/O 支持。

总而言之，C++20 的协程为异步编程提供了一个更简洁、高效且易维护的途径。无论是网络编程、文件 I/O，还是 GPU 计算，协程都能让代码更像同步逻辑，降低错误率，并提升性能。

发表评论