1. 为什么我们需要协程？
在传统的C++开发中，线程一直是处理并发任务的主要手段。但线程存在几个显著问题：创建和切换开销大（通常需要微秒级）、内存占用高（每个线程需要独立的栈空间，通常MB级别）、同步复杂（需要各种锁机制）。这些问题在需要处理大量轻量级并发任务时尤为突出。
协程（Coroutine）提供了一种更轻量级的解决方案。它允许函数在执行过程中暂停，并在之后恢复执行，而无需创建多个线程。从操作系统角度看，所有协程都在同一个线程中运行，但开发者可以像使用线程一样编写异步代码。
关键区别：线程是操作系统级别的概念，由内核调度；协程是用户态的概念，由程序自身控制调度。
2. C++20中的协程标准
C++20首次将协程作为语言特性引入标准库。这套机制基于三个核心概念：
2.1 协程框架组件
- 协程句柄（coroutine_handle）：用于暂停和恢复协程的执行
- 协程承诺（promise_type）：定义协程的行为和返回机制
- 协程状态（coroutine state）：存储暂停时的局部变量和恢复点
一个最简单的协程函数声明如下：
cpp复制#include <coroutine>
struct ReturnObject {
struct promise_type {
ReturnObject get_return_object() { return {}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void unhandled_exception() {}
};
};
ReturnObject my_coroutine() {
co_await std::suspend_always{};
}
2.2 协程控制流程
当调用协程函数时，实际发生以下步骤：
- 分配协程状态（通常在堆上）
- 构造promise对象
- 调用get_return_object()获取返回值
- 执行initial_suspend()并可能暂停
- 执行协程函数体
- 执行final_suspend()并可能暂停
- 销毁promise对象和协程状态
2.3 协程挂起与恢复
co_await是协程的核心操作符，它的工作流程：
- 调用await_ready()检查是否需要挂起
- 如果返回false，则挂起协程并调用await_suspend()
- 恢复时调用await_resume()并获取结果
3. 实战：构建异步IO协程
让我们通过一个实际案例展示协程如何简化异步编程。我们将实现一个异步读取文件的协程：
cpp复制#include <iostream>
#include <fstream>
#include <coroutine>
#include <future>
struct AsyncReadResult {
std::string content;
bool ready = false;
};
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 = r; }
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> handle;
AsyncReadResult get() {
if (!handle.done()) {
handle.resume();
}
return handle.promise().result;
}
~AsyncFileReader() { if (handle) handle.destroy(); }
};
AsyncFileReader async_read_file(const std::string& path) {
AsyncReadResult result;
// 模拟异步读取
std::thread([&] {
std::ifstream file(path);
result.content.assign(
(std::istreambuf_iterator<char>(file)),
std::istreambuf_iterator<char>()
);
result.ready = true;
}).detach();
co_return result;
}
int main() {
auto reader = async_read_file("example.txt");
while (true) {
auto result = reader.get();
if (result.ready) {
std::cout << result.content << std::endl;
break;
}
std::cout << "Waiting..." << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
4. 协程性能优化技巧
4.1 内存分配优化
默认情况下，协程状态在堆上分配。对于高频使用的协程，可以考虑自定义分配器：
cpp复制struct custom_allocator {
static void* operator new(size_t size) {
if (auto ptr = my_memory_pool.allocate(size))
return ptr;
return ::operator new(size);
}
static void operator delete(void* ptr, size_t size) {
if (my_memory_pool.contains(ptr))
my_memory_pool.deallocate(ptr, size);
else
::operator delete(ptr);
}
};
struct OptimizedCoroutine : custom_allocator {
// ... promise_type定义
};
4.2 协程切换开销分析
协程切换通常比线程切换快10-100倍。以下是在x86_64平台上的典型数据：
| 操作 | 平均耗时 |
|---|---|
| 线程切换（同一进程） | 1.2μs |
| 协程切换（无IO） | 15ns |
| 函数调用 | 3ns |
4.3 协程与线程池配合
最佳实践是将协程与线程池结合使用：
cpp复制ThreadPool pool(4); // 4个工作线程
Task<> process_data() {
auto data = co_await async_read("data.bin");
auto processed = co_await pool.execute(heavy_computation, data);
co_await async_write("result.bin", processed);
}
5. 常见问题与调试技巧
5.1 协程内存泄漏检测
由于协程状态可能长时间挂起，容易造成内存泄漏。可以使用以下方法检测：
cpp复制struct TracingPromise {
static int count;
TracingPromise() { ++count; }
~TracingPromise() { --count; }
// ...其他成员
};
// 定期检查
if (TracingPromise::count > 100) {
std::cerr << "Possible coroutine leak: " << TracingPromise::count << "\n";
}
5.2 协程调试工具
- GDB/LLDB：最新版本支持协程帧检查
code复制(gdb) info coroutines - Clang协程可视化工具：
-fcoroutines-ts -Xclang -fcoroutines-debug - 自定义追踪：在promise_type中添加日志
5.3 协程异常处理
协程中的异常需要特别注意：
cpp复制struct SafeCoroutine {
struct promise_type {
std::exception_ptr eptr;
void unhandled_exception() {
eptr = std::current_exception();
}
// ...其他成员
};
void check_exception() {
if (handle.promise().eptr)
std::rethrow_exception(handle.promise().eptr);
}
};
6. 协程在游戏开发中的应用
游戏引擎通常是协程的理想应用场景。以Unity为例，其协程系统与C++20协程有相似之处：
6.1 游戏循环集成
cpp复制struct FrameAwaiter {
bool await_ready() { return false; }
void await_suspend(std::coroutine_handle<> h) {
game_engine::register_coroutine(h);
}
void await_resume() {}
};
Task<> enemy_ai() {
while (enemy.alive) {
co_await FrameAwaiter{}; // 每帧执行一次
update_enemy_position();
}
}
6.2 动画序列处理
cpp复制Task<> play_cutscene() {
co_await fade_in(2.0f); // 淡入2秒
co_await show_dialog("Hello World");
co_await wait_for_input();
co_await fade_out(1.0f);
}
7. 协程与其他技术的对比
7.1 协程 vs 回调
回调地狱（Callback Hell）：
cpp复制async_read("a.txt", [](Data a){
async_read("b.txt", [a](Data b){
async_write("c.txt", process(a,b), []{
// 更多嵌套...
});
});
});
协程版本：
cpp复制Task<> process_files() {
auto a = co_await async_read("a.txt");
auto b = co_await async_read("b.txt");
co_await async_write("c.txt", process(a,b));
}
7.2 协程 vs 反应式编程
反应式编程（如RxCpp）：
cpp复制auto sub = observable::from("a.txt")
.flat_map([](auto path){ return async_read(path); })
.subscribe([](auto data){ /* 处理数据 */ });
协程版本通常更直观，特别是对于线性逻辑。
8. 协程高级模式
8.1 生成器模式
cpp复制Generator<int> fibonacci() {
int a = 0, b = 1;
while (true) {
co_yield a;
auto next = a + b;
a = b;
b = next;
}
}
for (auto num : fibonacci()) {
if (num > 1000) break;
std::cout << num << " ";
}
8.2 多播协程
一个协程可以被多个消费者等待：
cpp复制struct SharedTask {
struct promise_type {
std::vector<std::coroutine_handle<>> waiters;
std::optional<Result> result;
void return_value(Result r) {
result = r;
for (auto h : waiters) h.resume();
}
// ...其他成员
};
};
9. 协程最佳实践
- 避免在协程中阻塞：协程的优势在于非阻塞IO，阻塞调用会破坏这一优势
- 限制协程生命周期：明确协程的创建和销毁时机，避免悬挂协程
- 合理设置栈大小：虽然协程栈比线程栈小，但仍需根据需求调整
- 注意异常安全：协程中的异常传播路径与普通函数不同
- 性能关键路径慎用：协程有一定开销，在纳秒级关键路径可能需要避免
10. 协程生态系统
现代C++协程生态系统正在快速发展：
-
库支持：
- cppcoro（微软）
- Boost.Coroutine2
- folly::coro（Facebook）
-
编译器支持：
- MSVC：完全支持
- Clang：基本支持
- GCC：逐步完善中
-
工具链：
- Visual Studio调试器
- Clang协程分析工具
- 各种性能分析器
在实际项目中，根据目标平台和编译器选择合适的协程实现方案。对于新项目，建议直接从C++20标准协程开始；对于遗留项目，可以考虑逐步引入协程，先从非关键路径开始试点。