C++中的协程：从概念到实践

作者

协程是C++20引入的一项强大特性，旨在简化异步编程与并发任务的实现。与传统的线程或回调机制相比，协程允许函数在执行过程中暂停并恢复，从而实现更直观、更易维护的异步代码。本文将从协程的基本概念、语法特性、实现细节以及实际应用场景展开讨论，帮助读者快速上手并将协程运用到自己的项目中。

1. 协程的基本概念

1.1 什么是协程？

协程是一种轻量级的用户级线程，能够在函数内部随时挂起执行状态，并在需要时恢复。与线程不同，协程共享调用栈，不需要频繁的上下文切换开销；与回调机制不同，协程代码保持了线性、同步的写法。

1.2 协程的三大要素

  1. 挂起点（Suspend）：函数在某处暂停执行，并保存当前上下文。
  2. 恢复点（Resume）：外部或内部触发协程恢复，继续执行。
  3. 状态机（State Machine）：编译器将协程转换为内部状态机，以便在挂起和恢复之间维护状态。

2. C++协程语法

2.1 co_await

co_await 用于挂起协程，等待一个 awaitable 对象完成。若 awaitable 对象可立即完成，则协程不挂起。

std::future <int> async_add(int a, int b) {
    return co_return a + b; // 简单返回
}

2.2 co_yield

co_yield 用于生成器协程，逐个产出值。调用方使用 co_await 读取这些值。

std::generator <int> range(int start, int end) {
    for (int i = start; i <= end; ++i)
        co_yield i;
}

2.3 co_return

co_return 用于终止协程并返回最终值。若返回值为 void，则仅终止。

std::future <void> wait_and_print(std::chrono::seconds delay) {
    co_await std::suspend_always{};
    std::this_thread::sleep_for(delay);
    std::cout << "Done!\n";
}

2.4 Awaitable 类型

任意类型，只要满足以下接口，即可被 co_await：

  • operator co_await 返回一个 Awaiter。
  • Awaiter 必须实现 await_ready()、await_suspend()、await_resume()。

示例：

struct Awaitable {
    bool await_ready() noexcept { return false; }
    void await_suspend(std::coroutine_handle<> h) noexcept { /* schedule */ }
    int await_resume() noexcept { return 42; }
};

3. 编译器实现细节

C++协程本质上是由编译器将协程函数转化为一个状态机结构。核心步骤：

  1. 生成状态枚举：每个 co_await、co_yield、co_return 的位置对应一个状态。
  2. 保存上下文：编译器自动插入 promise_type 用于保存局部变量与协程状态。
  3. 实现 resume 与 destroy：提供协程句柄接口，允许外部恢复或销毁协程。

常见的 promise_type 示例：

template<typename T>
struct Promise {
    T value_;
    std::suspend_always initial_suspend() { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    T get_return_value() { return value_; }
    void return_value(T v) { value_ = v; }
};

4. 常见协程模型

4.1 异步 I/O

协程可以包装异步 I/O 操作，隐藏回调链。例如：

std::future<std::string> read_file_async(const std::string& path) {
    co_await async_io::open(path);
    std::string data = co_await async_io::read();
    co_return data;
}

4.2 生成器

使用 std::generator 生成无限序列或惰性计算。

for (auto x : range(1, 5))
    std::cout << x << " ";

4.3 任务调度器

协程与事件循环结合，实现轻量级协程调度。例如：

class Scheduler {
public:
    void schedule(std::coroutine_handle<> h) { queue_.push_back(h); }
    void run() {
        while (!queue_.empty()) {
            auto h = queue_.front();
            queue_.pop_front();
            h.resume();
        }
    }
private:
    std::deque<std::coroutine_handle<>> queue_;
};

5. 实战案例：协程实现 HTTP 客户端

#include <asio.hpp>
#include <iostream>
#include <coroutine>

using asio::awaitable;
using asio::co_spawn;
using asio::use_awaitable;
using asio::ip::tcp;

awaitable<std::string> http_get(const std::string& host, const std::string& path) {
    tcp::resolver resolver(co_await use_awaitable);
    auto endpoints = co_await resolver.resolve(host, "http", use_awaitable);

    tcp::socket socket(co_await use_awaitable);
    co_await asio::async_connect(socket, endpoints, use_awaitable);

    std::string request = "GET " + path + " HTTP/1.1\r\nHost: " + host + "\r\n\r\n";
    co_await asio::async_write(socket, asio::buffer(request), use_awaitable);

    asio::streambuf response;
    co_await asio::async_read_until(socket, response, "\r\n\r\n", use_awaitable);

    std::istream resp_stream(&response);
    std::string status_line;
    std::getline(resp_stream, status_line);
    std::cout << "Status: " << status_line << "\n";

    return std::string((std::istreambuf_iterator <char>(resp_stream)), {});
}

int main() {
    asio::io_context io;
    co_spawn(io, http_get("example.com", "/"), asio::detached);
    io.run();
}

6. 性能与注意事项

  1. 栈大小：协程共享栈，避免栈溢出；但递归协程需谨慎。
  2. 异常传播：协程支持异常抛出与捕获，promise_type 的 final_suspend 可用于清理。
  3. 调试难度：暂停点不易跟踪，建议使用 IDE 的协程调试器或打印日志。

7. 未来展望

  • 协程池：实现协程对象复用，减少创建销毁开销。
  • 分布式协程：跨进程、跨机器的协程协作。
  • 与反应式编程结合：协程与 Rx、Streams 等模型的深度融合。

通过本文的介绍，你已经了解了 C++ 协程的核心概念、语法细节、实现机制以及典型应用。接下来可以尝试将协程嵌入自己的项目，例如实现异步数据库访问、实时数据流处理或高性能网络服务器。协程为 C++ 提供了一条更直观、更高效的并发编程路径，值得在实际开发中广泛应用。

发表评论