1. 协程编程的本质与价值

在C++20标准之前，我们处理异步操作往往需要依赖回调函数、事件循环或多线程方案。这些传统方式要么导致"回调地狱"使代码难以维护，要么因线程切换开销影响性能。协程（Coroutine）的引入彻底改变了这一局面——它允许函数在执行过程中暂停和恢复，同时保持局部状态不丢失。

举个实际例子：假设我们需要从网络下载10个文件然后处理。传统多线程方案需要创建线程池、管理锁和条件变量；而用协程可以这样写：

Task<> downloadAndProcess() { for(int i=0; i<10; ++i) { auto data = co_await downloadAsync(urls[i]); process(data); } }

这段代码看起来是同步的，但实际上每个co_await点都会暂停执行直到下载完成，期间线程可以去做其他工作。这就是协程的魔力——用同步的写法实现异步的效果。

2. C++20协程核心机制解析

2.1 协程三大核心组件

C++20的协程实现基于三个关键组件：

1. Promise对象：每个协程都有一个关联的promise对象，负责协程的初始和最终行为。通过它我们可以自定义：

   • 协程的返回值类型
   • 异常处理方式
   • 最终清理逻辑

2. 协程句柄：类型为std::coroutine_handle，用于显式控制协程的生命周期。通过它可以：

   • 恢复协程执行
   • 销毁协程帧
   • 检查协程状态

3. Awaitable对象：决定co_await的行为。关键是要实现三个方法：

   • await_ready()：是否可以直接继续执行
   • await_suspend()：挂起时执行的逻辑
   • await_resume()：恢复时返回的值

2.2 协程状态机详解

每个协程在编译期会被转换为状态机。以下面的简单协程为例：

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

编译器会生成类似如下的状态机：

1. 初始状态：分配协程帧，初始化promise对象
2. 运行状态：执行到第一个挂起点
3. 挂起状态：保存所有局部变量和当前执行位置
4. 恢复状态：从上次挂起点继续执行
5. 结束状态：执行promise的final_suspend

关键提示：协程帧的内存分配默认通过operator new实现，对于高性能场景应该自定义分配器。

3. 手把手实现协程类型

3.1 实现一个Generator

让我们实现一个最常用的协程类型——Generator，它可以用来生成序列：

template<typename T> struct Generator { struct promise_type { T current_value; auto get_return_object() { return Generator{handle_type::from_promise(*this)}; } auto initial_suspend() { return std::suspend_always{}; } auto final_suspend() noexcept { return std::suspend_always{}; } void unhandled_exception() { std::terminate(); } auto yield_value(T value) { current_value = value; return std::suspend_always{}; } void return_void() {} }; using handle_type = std::coroutine_handle<promise_type>; explicit Generator(handle_type h) : handle(h) {} ~Generator() { if(handle) handle.destroy(); } bool next() { if(!handle.done()) { handle.resume(); } return !handle.done(); } T value() const { return handle.promise().current_value; } private: handle_type handle; };

使用示例：

Generator<int> range(int start, int end) { for(int i=start; i<end; ++i) { co_yield i; } } void test() { auto gen = range(1, 5); while(gen.next()) { std::cout << gen.value() << " "; } // 输出：1 2 3 4 }

3.2 实现Task协程

对于异步操作，我们需要实现可以等待的Task：

template<typename T> struct Task { struct promise_type { std::variant<T, std::exception_ptr> result; std::coroutine_handle<> continuation; Task get_return_object() { return Task{*this}; } auto initial_suspend() { return std::suspend_always{}; } auto final_suspend() noexcept { struct Awaiter { bool await_ready() noexcept { return false; } void await_suspend(std::coroutine_handle<promise_type> h) noexcept { if(h.promise().continuation) { h.promise().continuation.resume(); } } void await_resume() noexcept {} }; return Awaiter{}; } void unhandled_exception() { result = std::current_exception(); } void return_value(T value) { result = std::move(value); } }; bool await_ready() { return false; } void await_suspend(std::coroutine_handle<> h) { coro.promise().continuation = h; coro.resume(); } T await_resume() { if(std::holds_alternative<std::exception_ptr>(coro.promise().result)) { std::rethrow_exception(std::get<std::exception_ptr>(coro.promise().result)); } return std::get<T>(coro.promise().result); } ~Task() { if(coro) coro.destroy(); } private: explicit Task(promise_type& p) : coro(std::coroutine_handle<promise_type>::from_promise(p)) {} std::coroutine_handle<promise_type> coro; };

4. 协程实战技巧与性能优化

4.1 内存分配优化

协程帧默认使用new/delete分配内存，这可能导致性能问题。我们可以自定义分配器：

template<typename T, typename Allocator = std::allocator<T>> struct AllocatorAwarePromise { using allocator_type = Allocator; allocator_type get_allocator() const { return allocator; } void* operator new(size_t size) { return allocator.allocate(size); } void operator delete(void* ptr, size_t size) { allocator.deallocate(static_cast<T*>(ptr), size); } private: static inline allocator_type allocator{}; };

4.2 协程与多线程结合

虽然协程本身不是线程，但可以很好与线程池配合：

ThreadPool pool(4); Task<int> computeOnThreadPool() { co_await pool.schedule(); // 现在在线程池线程上执行 auto result = heavyComputation(); co_return result; }

4.3 调试协程的技巧

调试协程可能会遇到一些特殊问题：

1. 协程帧查看：在调试器中查看std::coroutine_handle的_Ptr成员可以访问协程帧
2. 状态检查：通过handle.done()判断协程是否执行完毕
3. 断点设置：在promise的各个关键方法设置断点观察生命周期
4. 异常追踪：确保promise的unhandled_exception被正确实现

5. 常见问题解决方案

5.1 协程不执行怎么办？

检查清单：

1. 是否调用了resume()启动协程？
2. initial_suspend()是否返回了suspend_always？
3. 协程对象是否被提前析构？

5.2 内存泄漏如何排查？

使用以下方法检测：

struct TraceAlloc { static int count; void* operator new(size_t size) { ++count; return ::operator new(size); } void operator delete(void* ptr) { --count; ::operator delete(ptr); } };

5.3 如何实现超时控制？

通过自定义awaiter实现超时：

template<typename Duration> struct TimeoutAwaiter { bool await_ready() { return false; } void await_suspend(std::coroutine_handle<> h) { timer.async_wait([h](auto...) { h.resume(); }); timer.expires_after(duration); } void await_resume() { if(timer.expiry() <= std::chrono::steady_clock::now()) { throw std::runtime_error("Timeout"); } } Duration duration; asio::steady_timer timer; };

6. 协程在游戏开发中的应用

游戏开发是协程的绝佳应用场景。比如实现一个NPC的行为逻辑：

Task<> npcBehavior() { while(true) { // 巡逻 for(int i=0; i<5; ++i) { co_await moveTo(waypoints[i]); } // 暂停10秒 co_await delay(10s); // 播放动画 playAnimation("idle"); co_await waitForAnimationComplete(); } }

这种写法比传统的状态机方式清晰得多，而且不需要手动管理状态。

7. 协程性能实测对比

我们测试了10万次简单计算任务：

测试环境：i7-11800H, Windows 11, MSVC 2022

协程的优势主要体现在：

1. 无线程切换开销
2. 更少的内存分配
3. 更好的缓存局部性

8. 协程与其他语言的对比

C++协程与其它语言实现的区别：

C++协程的优势在于极致性能和控制力，代价是需要更多样板代码。