1. 为什么C++需要协程?
在传统的C++异步编程中,我们通常面临以下几种选择:
- 回调地狱(Callback Hell)
- 基于Future/Promise的模式
- 第三方库(如Boost.Asio)
- 原生线程(std::thread)
这些方法各有优劣,但都存在一些根本性问题。回调地狱导致代码难以维护;Future/Promise虽然解决了回调嵌套问题,但仍然不够直观;第三方库增加了项目依赖;原生线程则太重,上下文切换开销大。
关键问题:一个简单的异步操作需要多少额外代码?
以网络请求为例,传统方式可能需要:
- 回调函数
- 错误处理
- 状态管理
- 线程同步
C++20协程的引入,从根本上改变了这种局面。它提供了:
- 同步风格的异步代码
- 无栈协程(Stackless Coroutine)
- 编译器生成的状态机
- 零额外内存分配(理想情况下)
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. C++20协程核心机制解析
2.1 协程的三个关键组件
C++20协程规范定义了三个核心概念:
-
协程句柄(Coroutine Handle)
- 类型为std::coroutine_handle<>
- 用于恢复或销毁协程
- 可通过promise_type::get_return_object()获取
-
承诺对象(Promise Object)
- 定义协程的行为
- 必须包含特定方法如initial_suspend(), final_suspend()
- 控制协程的初始化和销毁逻辑
-
协程状态(Coroutine State)
- 编译器自动生成
- 包含:
- 参数
- 局部变量
- 挂起点位置
- promise对象
2.2 协程的执行流程
一个典型的协程生命周期如下:
- 分配协程状态(可能在堆上或通过定制分配器)
- 拷贝参数到协程状态
- 构造promise对象
- 调用promise.get_return_object()(结果给调用者)
- 调用promise.initial_suspend()并await其结果
- 执行协程体直到第一个挂起点
- 当协程挂起时,控制权返回给调用者或恢复者
2.3 协程的内存模型
理解内存分配对性能至关重要:
cpp复制struct MyCoroutine {
struct promise_type {
MyCoroutine get_return_object() {
return MyCoroutine(std::coroutine_handle<promise_type>::from_promise(*this));
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> h_;
explicit MyCoroutine(std::coroutine_handle<promise_type> h) : h_(h) {}
~MyCoroutine() { if (h_) h_.destroy(); }
};
优化技巧:
- 使用自定义分配器避免频繁堆分配
- 小协程可以考虑在栈上分配
- 协程状态大小取决于局部变量数量
3. 实战:构建异步HTTP客户端
3.1 基础框架搭建
我们先定义一个简单的awaitable类型:
cpp复制struct io_awaitable {
bool await_ready() { return false; }
void await_suspend(std::coroutine_handle<> h) {
// 将h存储到IO完成回调中
}
void await_resume() {
// 检查错误并抛出异常
}
};
3.2 实现GET请求
cpp复制task<std::string> http_get(std::string url) {
auto conn = co_await connect(url);
auto resp = co_await conn.send("GET / HTTP/1.1\r\nHost: " + url + "\r\n\r\n");
co_return resp;
}
3.3 错误处理模式
协程中的错误处理有两种主要方式:
- 使用异常:
cpp复制try {
auto data = co_await async_op();
} catch(const std::exception& e) {
// 处理错误
}
- 使用expected类型:
cpp复制auto result = co_await async_op().as_expected();
if (!result) {
// 处理错误
}
4. 高级技巧与性能优化
4.1 协程组合
如何组合多个协程:
cpp复制task<void> fetch_multiple() {
auto [r1, r2] = co_await when_all(http_get("url1"), http_get("url2"));
// 处理结果
}
4.2 避免常见陷阱
- 悬空引用:
cpp复制task<void> bad_example() {
std::string& ref = some_global;
co_await something(); // 可能some_global已销毁
ref = "oops"; // 悬空引用
}
- 内存泄漏:
cpp复制task<void> leaky() {
auto p = new int(42);
co_await something();
delete p; // 如果协程提前销毁,这里会泄漏
}
解决方案:使用RAII对象
4.3 性能调优
-
协程状态大小分析:
- 使用sizeof查看协程框架大小
- 避免在协程中存储大对象
-
上下文切换开销测量:
cpp复制auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < 1000000; ++i) {
co_await trivial_awaitable{};
}
auto end = std::chrono::high_resolution_clock::now();
- 分配器优化:
cpp复制template<typename T>
struct my_allocator {
static void* operator new(size_t size) {
return pool_alloc(size);
}
static void operator delete(void* ptr) {
pool_free(ptr);
}
};
5. 与其他技术的对比
5.1 协程 vs 线程
| 特性 | 协程 | 线程 |
|---|---|---|
| 切换开销 | 极低(几十ns) | 高(微秒级) |
| 内存占用 | 通常几KB | 至少几MB |
| 并行性 | 单线程 | 真并行 |
| 系统调用 | 无 | 需要 |
| 适用场景 | IO密集型 | CPU密集型 |
5.2 C++20协程 vs 其他语言协程
-
Kotlin协程:
- 有栈协程
- 更高级的API
- 与语言深度集成
-
Python异步:
- 事件循环必需
- 语法更简洁
- 动态类型
-
Go协程:
- 有栈协程
- 自动调度
- 内存占用更大
C++20协程的优势在于:
- 零开销抽象
- 与现有代码无缝集成
- 极高的灵活性
6. 实际项目集成案例
6.1 高并发服务器设计
cpp复制task<void> handle_client(tcp_connection conn) {
try {
while (true) {
auto data = co_await conn.read();
auto processed = process(data);
co_await conn.write(processed);
}
} catch (const connection_closed&) {
// 客户端断开
}
}
task<void> server_main() {
auto acceptor = tcp_acceptor(8080);
while (true) {
auto conn = co_await acceptor.accept();
spawn(handle_client(std::move(conn)));
}
}
6.2 游戏引擎中的协程应用
cpp复制task<void> play_cutscene() {
co_await show_dialog("Welcome to the castle");
co_await fade_in();
co_await delay(2s);
co_await character.walk_to(target);
co_await play_animation("open_door");
}
6.3 并行计算任务
cpp复制task<double> compute_pi(int iterations) {
std::vector<task<do
