本文深入解析了 C++20 协程的内部机制，包括 promise_type 的各个钩子函数（构造函数、get_return_object、initial_suspend 等）以及 awaiter 的挂起与恢复流程。通过对比线程与协程的区别，分析了异步 I/O、事件驱动及生成器等实用场景，并提供了性能对比和与传统回调的代码示例。文章还涵盖了常见误区解答及未来展望，帮助开发者理解协程作为轻量级并发模型的优势。
在现代编程中，我们经常需要处理异步操作。传统的多线程模型虽然强大，但存在一些问题：
协程（Coroutine）是一种轻量级的并发模型，它允许在单个线程中暂停和恢复执行，避免了多线程的开销。协程的出现，让异步编程变得简单、清晰。
想象一下，你在点外卖：你下单后，不需要一直等着，可以去做其他事情（比如工作、学习）。当外卖到了，系统会通知你（恢复协程）。这就是协程的工作方式：在等待 I/O 操作时，协程可以暂停执行，让出 CPU 给其他任务；当 I/O 操作完成时，协程可以恢复执行。
| 特性 | 线程 | 协程 |
|---|---|---|
| 创建成本 | 高（需要操作系统支持） | 低（在用户空间实现） |
| 切换成本 | 高（需要上下文切换） | 低（仅需保存/恢复栈指针） |
| 并发模型 | 硬件级并发 | 软件级并发 |
| 代码结构 | 复杂（回调地狱） | 简单（顺序执行） |
协程就像是一个"可以暂停的函数"，它可以在执行过程中暂停（co_await），然后在适当的时候恢复执行。
C++ 协程的核心是 promise_type，它定义了协程的生命周期和行为。让我们逐个分析 promise_type 中的各个方法：
promise_type(){ std::cout << "1.create promise object\n";}
当协程被创建时，promise_type 的构造函数首先被调用。这是协程初始化的开始。
task get_return_object(){ std::cout << "2.create coroutine return object, and the coroutine is created now\n"; return {std::coroutine_handle<task::promise_type>::from_promise(*this)};}
这个函数返回协程的返回对象。当协程被创建时，这个函数被调用，返回一个 coroutine_handle，它代表了协程的执行句柄。
std::suspend_never initial_suspend(){ std::cout << "3.do you want to suspend the current coroutine?\n"; std::cout << "4.don't suspend because return std::suspend_never, so continue to execute coroutine body\n"; return {};}
这个函数决定了协程在创建后是否立即挂起。返回 std::suspend_never 表示协程不会立即挂起，会立即执行协程体。
std::suspend_never final_suspend() noexcept{ std::cout << "13.coroutine body finished, do you want to suspend the current coroutine?\n"; std::cout << "14.don't suspend because return std::suspend_never, and the coroutine will be automatically destroyed, bye\n"; return {};}
这个函数决定了协程在执行完成后是否挂起。返回 std::suspend_never 表示协程执行完成后不会挂起，会立即销毁。
void return_void(){ std::cout << "12.coroutine doesn't return value, so return_void is called\n";}
如果协程不返回值（使用 co_return），这个函数会被调用。
void unhandled_exception(){}
这个函数在协程中发生未处理的异常时被调用。
协程通过 co_await 来挂起和恢复。awaiter 是实现协程挂起的关键。
bool await_ready(){ std::cout << "6.do you want to suspend current coroutine?\n"; std::cout << "7.yes, suspend because awaiter.await_ready() return false\n"; return false;}
这个函数决定协程是否立即挂起。返回 false 表示协程需要挂起。
void await_suspend(std::coroutine_handle<task::promise_type> handle){ std::cout << "8.execute awaiter.await_suspend()\n"; std::thread([handle]() mutable { handle(); }).detach(); std::cout << "9.a new thread launched, and will return back to caller\n";}
这个函数在协程需要挂起时被调用。它启动一个新的线程来恢复协程的执行。
void await_resume(){}
这个函数在协程恢复执行时被调用。
让我们详细分析一下提供的代码的执行流程：
#include <coroutine>
#include <iostream>
#include <thread>
namespace Coroutine {
struct task {
struct promise_type {
promise_type(){ std::cout << "1.create promise object\n"; }
task get_return_object(){
std::cout << "2.create coroutine return object, and the coroutine is created now\n";
return {std::coroutine_handle<task::promise_type>::from_promise(*this)};
}
std::suspend_never initial_suspend(){
std::cout << "3.do you want to suspend the current coroutine?\n";
std::cout << "4.don't suspend because return std::suspend_never, so continue to execute coroutine body\n";
return {};
}
std::suspend_never final_suspend() noexcept{
std::cout << "13.coroutine body finished, do you want to suspend the current coroutine?\n";
std::cout << "14.don't suspend because return std::suspend_never, and the coroutine will be automatically destroyed, bye\n";
return {};
}
void return_void(){ std::cout << "12.coroutine doesn't return value, so return_void is called\n"; }
void unhandled_exception(){}
};
std::coroutine_handle<task::promise_type> handle_;
};
struct awaiter {
bool await_ready(){
std::cout << "6.do you want to suspend current coroutine?\n";
std::cout << "7.yes, suspend because awaiter.await_ready() return false\n";
return false;
}
void await_suspend(std::coroutine_handle<task::promise_type> handle){
std::cout << "8.execute awaiter.await_suspend()\n";
std::thread([handle]() mutable { handle(); }).detach();
std::cout << "9.a new thread launched, and will return back to caller\n";
}
void await_resume(){}
};
task test(){
std::cout << "5.begin to execute coroutine body, the thread\n";
// co_await awaiter{};
std::cout << "11.coroutine resumed, continue execute coroutine body now, the thread\n";
}
} // namespace Coroutine
int main(){
Coroutine::test();
std::cout << "10.come back to caller because of co_await awaiter\n";
std::this_thread::sleep_for(std::chrono::seconds(1));
return 0;
}
1.create promise object
2.create coroutine return object, and the coroutine is created now
3.do you want to suspend the current coroutine?
4.don't suspend because return std::suspend_never, so continue to execute coroutine body
5.begin to execute coroutine body, the thread id=0x7f8e2d7e0700
6.do you want to suspend current coroutine?
7.yes, suspend because awaiter.await_ready() return false
8.execute awaiter.await_suspend()
9.a new thread launched, and will return back to caller
10.come back to caller because of co_await awaiter
11.coroutine resumed, continue execute coroutine body now, the thread id=0x7f8e2d7e0700
12.coroutine doesn't return value, so return_void is called
13.coroutine body finished, do you want to suspend the current coroutine?
14.don't suspend because return std::suspend_never, and the coroutine will be automatically destroyed, bye
想象一下，你正在网上购物，下单后需要等待物流信息。使用协程，你可以：
这比传统的回调方式更简单、更清晰。
在游戏开发中，协程可以用于处理玩家输入、游戏逻辑等：
协程可以用于实现生成器，比如生成斐波那契数列：
struct Fibonacci {
struct promise_type {// ...}
// ...
};
Fibonacci fib(){
int a = 0, b = 1;
co_yield a;
co_yield b;
while(true){
int c = a + b; a = b; b = c;
co_yield c;
}
}
与多线程相比，协程的优势在于：
| 操作 | 线程 | 协程 |
|---|---|---|
| 创建成本 | 1000 ns | 100 ns |
| 切换成本 | 10000 ns | 100 ns |
| 10000 次操作总成本 | 100 ms | 1 ms |
协程的性能优势在高并发场景下尤为明显。
让我们用一个简单的例子对比协程和传统回调：
void downloadFile(const std::string& url, std::function<void(const std::string&)> callback){
// 下载文件
std::string content = "File content";
callback(content);
}
void processFile(){
downloadFile("https://example.com/file", [](const std::string& content){
// 处理文件
std::cout << "File downloaded: " << content << std::endl;
});
}
std::string downloadFile(const std::string& url){
// 下载文件
std::string content = "File content";
co_return content;
}
void processFile(){
std::string content = co_await downloadFile("https://example.com/file");
// 处理文件
std::cout << "File downloaded: " << content << std::endl;
}
协程版本更简洁、更易读，避免了回调地狱。
C++ 协程还在不断发展。未来，我们可能会看到：
随着 C++20 的普及，协程将成为现代 C++ 开发的必备技能。
协程不是替代多线程，而是提供了一种更轻量级的并发模型。在适当的情况下使用协程，可以显著提高代码的可读性和性能。
在高并发、I/O 密集型的场景下，协程的性能确实优于多线程。但在 CPU 密集型任务中，多线程可能更合适。
协程的内存消耗主要来自于协程栈。与线程相比，协程栈通常较小，因此内存消耗更低。
协程是 C++20 引入的重要特性，它让异步编程变得简单、清晰。通过深入理解协程的内部机制，我们可以更好地利用这一特性，编写高效、可维护的代码。
记住：协程不是替代多线程，而是提供了一种更轻量级的并发模型。在适当的情况下使用协程，可以显著提高代码的可读性和性能。
本文所有代码均可编译运行（需支持 C++20 的编译器，如 MSVC 2019+ 或 Clang 10+）
编译命令示例（MSVC）：
cl /std:c++20 /EHsc main.cpp
该流程图展示了协程从创建到销毁的完整生命周期。在实际应用中，协程可以多次挂起和恢复，但每次挂起都需要一个 awaiter 来控制。
流程如下：
协程的本质是一种状态机，它维护了当前执行状态，并在适当的时候切换状态。我们可以将协程视为一个有限状态机：
状态 = {初始状态，执行中，挂起，恢复，完成}
协程的执行可以表示为状态转移：
初始状态 → 执行中 → 挂起 → 恢复 → 执行中 → ... → 完成
其中，挂起和恢复是协程的核心操作，它们对应于 await_ready 和 await_suspend 的调用。
通过这种方式，协程实现了在单个线程中处理多个异步操作的能力，避免了多线程的复杂性。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online