C++20 协程实战：从异步 I/O 到游戏循环的完整实现

作者

协程是 C++20 引入的一项强大特性，它通过 co_await、co_yield 和 co_return 让异步编程更加直观、易读。本文将带你深入了解协程的底层实现原理，结合实际案例演示如何在 C++ 中使用协程构建高效的异步 I/O、数据流处理以及游戏循环。

1. 协程的基础概念

1.1 什么是协程？

协程（Coroutine）是一种轻量级的函数，它可以在执行过程中暂停并恢复。与传统线程相比，协程的切换成本极低，内存占用更小，适合在 I/O 密集型或高频切换场景下使用。

1.2 协程的三大关键词

关键词 用途 典型示例
co_await 等待异步操作完成 int result = co_await asyncRead();
co_yield 产生序列值 co_yield i;
co_return 返回值并结束协程 co_return result;

2. 协程的底层实现原理

2.1 协程句柄（std::coroutine_handle）

协程句柄是协程的核心对象，负责管理协程的生命周期。它通过内部指针维护协程帧（栈帧），并提供 resume()、destroy() 等操作。

auto h = std::coroutine_handle<>::from_promise(promise);
h.resume();   // 继续执行协程
h.destroy();  // 销毁协程

2.2 协程状态机

编译器会把协程函数自动转换为状态机。每个 co_await、co_yield、co_return 对应一个状态点。状态机通过内部 promise_type 的 await_suspend、await_resume 等成员实现。

2.3 内存布局

  • 协程帧：包含局部变量、返回地址、协程状态等信息，存放在堆上（通过 operator new 分配）。
  • promise_type：实现协程返回值、异常处理以及 get_return_object() 等。

3. 实例：基于协程的异步文件读取

下面演示一个简易的异步文件读取器，利用协程实现非阻塞 I/O。

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

struct AsyncReadResult {
    std::string data;
    bool eof;
};

struct AsyncFileReader {
    struct promise_type {
        AsyncReadResult result;
        AsyncFileReader get_return_object() {
            return AsyncFileReader{std::coroutine_handle <promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_value(AsyncReadResult r) { result = std::move(r); }
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle <promise_type> handle;
    ~AsyncFileReader() { if (handle) handle.destroy(); }

    AsyncReadResult get() { return handle.promise().result; }
};

AsyncFileReader asyncReadFile(const std::string& filename, std::size_t chunkSize) {
    std::ifstream file(filename, std::ios::binary);
    if (!file) co_return { "", true };

    std::string buffer(chunkSize, '\0');
    while (file.read(buffer.data(), chunkSize) || file.gcount() > 0) {
        buffer.resize(file.gcount());
        co_yield AsyncReadResult{buffer, false};
        buffer.assign(chunkSize, '\0');
    }
    co_return { "", true }; // EOF
}

int main() {
    auto reader = asyncReadFile("sample.bin", 4096);
    for (auto chunk : reader) {
        std::cout << "Read " << chunk.data.size() << " bytes.\n";
    }
    std::cout << "File reading finished.\n";
}

说明

  • asyncReadFile 在每次读取完成后 co_yield 一个 AsyncReadResult。
  • main 通过范围 for 循环遍历每个协程生成的块，达到非阻塞效果。
  • 若需真正的异步 I/O（如使用 io_uring 或 Windows IOCP），需要在 await_suspend 中挂起协程并注册回调。

4. 协程在数据流处理中的应用

协程非常适合实现流式处理，例如：

auto filter = [](auto&& stream, auto&& predicate) -> auto {
    while (co_yield auto x = stream.next()) {
        if (predicate(x)) co_yield x;
    }
};

使用 co_yield 生成无限序列或处理网络数据包时，可以让代码保持同步可读。

5. 在游戏循环中的协程使用

在游戏引擎中，协程可以用来实现：

  1. 异步资源加载：后台加载纹理、模型，加载完成后恢复主线程。
  2. 动画控制：让角色动画以帧为单位逐步执行，支持暂停、回放。
  3. 状态机实现：用 co_yield 表达不同状态，避免大量 switch。
struct AI {
    std::string name;
    std::coroutine_handle<> h;

    AI(const std::string& n) : name(n) {}

    void start() {
        h = walk().handle;
        h.resume();
    }

    auto walk() -> std::coroutine_handle<> {
        while (true) {
            std::cout << name << " walking.\n";
            co_await std::suspend_always(); // 等待下一帧
        }
    }
};

每帧调用 h.resume() 即可。

6. 协程常见陷阱与调试技巧

陷阱 原因 解决方案
协程对象持久化导致悬空引用 协程内部引用外部对象生命周期短 使用 std::shared_ptr 或手动管理资源
频繁创建协程导致性能下降 每个协程都分配堆帧 复用协程对象或使用 std::generator
断点调试不连贯 协程切换隐藏在生成器内部 使用 -g 并结合 gdb 的 frame 命令

7. 结语

C++20 的协程为异步编程提供了天然的语法糖，使代码更接近同步写法，同时保持了高性能。无论是文件 I/O、网络通信还是游戏状态机，协程都能以简洁的方式解决传统 callback 的复杂性。随着标准的进一步完善和第三方库（如 asio、cppcoro 等）的成熟，协程将在更广阔的领域得到应用。欢迎大家尝试将协程引入自己的项目，感受其带来的代码简洁与运行效率提升。

发表评论