C++20协程：轻松实现异步编程

作者

在 C++20 中引入的协程（coroutines）为异步编程提供了一个高效、直观且与语言本身无缝集成的解决方案。相比传统的基于回调、状态机或线程池的异步实现，协程能够让代码保持同步的写法，同时实现非阻塞的执行。下面我们从基础概念、语法细节、典型使用场景以及性能注意点等方面，系统性地介绍 C++20 协程，并给出实战代码示例。

1. 协程基础

1.1 协程与函数的区别

传统函数在调用时会一次性执行完毕，并在返回时将栈全部销毁。而协程可以在执行过程中“挂起”（suspend），保存当前执行状态（局部变量、指令指针等），随后可以恢复继续执行。挂起与恢复的过程由协程的“状态机”实现，C++20 通过 co_await、co_yield 和 co_return 关键字标记挂起点。

1.2 协程的三大组件

组件 作用
协程生成器（promise_type） 定义协程的入口、退出和异常处理行为；保存协程状态。
协程句柄（std::coroutine_handle） 用于控制协程的执行：resume、destroy、检查是否完成等。
协程返回类型 通过 co_return 或 co_yield 返回的值，常见的有 `std::future
、std::generator` 等。

2. 语法细节

2.1 声明协程

#include <coroutine>
#include <iostream>
#include <string_view>

std::future<std::string_view> fetchData() {
    std::string_view data = "Hello, coroutine!";
    co_return data;            // 立即返回
}

2.2 使用 co_await

std::future <int> computeAsync() {
    int result = 42;
    co_return result;          // 也可以直接返回
}

2.3 使用 co_yield（生成器）

#include <generator>  // C++23 标准库中定义
std::generator <int> range(int start, int end) {
    for (int i = start; i < end; ++i)
        co_yield i;          // 每次挂起并返回一个值
}

2.4 错误处理

协程内部抛出的异常会被包装进 std::future 或 std::generator 的状态中，调用者可以通过 future.get() 捕获：

auto fut = computeAsync();
try {
    int val = fut.get();   // 若协程抛出异常，此处会抛出
    std::cout << val << '\n';
} catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << '\n';
}

3. 典型使用场景

3.1 异步 I/O

在网络库（如 Boost.Asio、libuv）中，协程可以配合事件循环实现非阻塞 I/O：

#include <boost/asio.hpp>
#include <boost/asio/steady_timer.hpp>

boost::asio::awaitable <void> asyncRead(boost::asio::ip::tcp::socket& sock) {
    char buffer[1024];
    std::size_t n = co_await sock.async_read_some(boost::asio::buffer(buffer), boost::asio::use_awaitable);
    std::cout << "Received " << n << " bytes\n";
}

3.2 任务调度

协程可以与任务队列结合，形成协作式多任务调度：

std::vector<std::coroutine_handle<>> workers;

void spawn(std::coroutine_handle<> h) {
    workers.push_back(h);
}

void run() {
    for (auto& h : workers) {
        if (!h.done()) h.resume();
    }
}

3.3 并发计算

利用 std::async 或自定义线程池，协程可以对 CPU 密集任务进行分块执行：

std::future <int> parallelSum(const std::vector<int>& data) {
    std::size_t mid = data.size() / 2;
    auto left = std::async(std::launch::async, [&]{
        return std::accumulate(data.begin(), data.begin() + mid, 0);
    });
    int right = std::accumulate(data.begin() + mid, data.end(), 0);
    co_return left.get() + right;
}

4. 性能注意点

  1. 避免频繁挂起：每次挂起/恢复都需要状态机开销。只在真正需要异步等待时使用 co_await。
  2. 内存占用：协程的状态会驻留在堆上，过多的协程实例会导致内存碎片。使用对象池或共享状态可以减少分配。
  3. 异常开销：协程异常通过堆栈捕获，若异常频繁抛出会影响性能。优先使用错误码返回。
  4. 编译器支持：不同编译器对 C++20 协程的优化程度不同，测试不同版本（gcc 11/12、clang 13/14、MSVC 19.28 等）可获得更好性能。

5. 小结

C++20 协程为异步编程带来了语义清晰、易维护的写法。通过 co_await、co_yield 与 co_return 的组合，开发者可以用同步的方式描述异步逻辑，极大提升代码可读性与开发效率。虽然协程本身是一种轻量级的线程，但其性能与可扩展性仍需在实际项目中进行评估与调优。掌握好协程的语法、生命周期与优化技巧，便能在现代 C++ 开发中游刃有余。

祝你编码愉快！

发表评论