答案：文章介绍了协程库的实现原理，先通过ucontext实现上下文切换构建简单协程，再对比C++20原生协程特性。1. 协程是用户态轻量级线程，依赖上下文保存与恢复实现挂起和继续；2. 使用getcontext/setcontext/swapcontext进行上下文切换，配合栈空间和状态管理完成协程调度；3. 示例展示了两个协程交替执行，体现协作式多任务；4. C++20引入co_await/co_yield/co_return关键字，需定义满足协程traits的返回类型如generator；5. 原生协程更安全标准但调试难，手动实现有助于理解异步本质，生产环境推荐使用标准库或成熟框架。
实现一个简单的协程库，核心在于上下文切换和状态管理。C++标准库目前（截至C++23）提供了原生协程支持（co_await、co_yield等），但理解底层原理有助于掌握异步编程本质。这里我们用ucontext或手动汇编实现上下文切换，构建一个极简协程库。
协程基本概念与上下文切换原理
协程是一种用户态的轻量级线程，可以主动让出执行权并在后续恢复。与线程不同，协程的调度由程序控制，无需内核介入，开销更小。
关键机制是上下文保存与恢复：当协程挂起时，保存当前寄存器状态（包括栈指针、程序计数器等）；恢复时，将这些状态重新载入CPU，从而从上次停下的位置继续执行。
在类Unix系统中，getcontext / setcontext / swapcontext 是一组可用于实现上下文切换的函数（尽管已被标记为过时，但便于教学）。
立即学习“C++免费学习笔记（深入）”；
使用ucontext实现简单协程
下面是一个基于ucontext的极简协程示例：
#include <ucontext.h>
#include <iostream>
#include <map>
<p>class Coroutine {
public:
using Func = void(*)();</p><p>private:
ucontext<em>t ctx</em>;
char stack<em>[8192];
Func func</em>;
bool is<em>done</em> = false;</p><p>public:
Coroutine(Func f) : func<em>(f) {
getcontext(&ctx</em>);
ctx_.uc_stack.ss<em>sp = stack</em>;
ctx_.uc_stack.ss<em>size = sizeof(stack</em>);
ctx_.uc<em>link = nullptr; // 协程结束返回主线程
makecontext(&ctx</em>, (void(*)())func_, 0);
}</p><pre class="brush:php;toolbar:false;">void resume() {
if (!is_done_) {
swapcontext(&MainContext::get(), &ctx_);
// 检查是否执行完毕
if (!is_done_ && ctx_.uc_link == nullptr) {
is_done_ = true;
}
}
}
bool done() const { return is_done_; }
static ucontext_t& get_main_context() {
static ucontext_t main_ctx;
static bool init = false;
if (!init) {
getcontext(&main_ctx);
init = true;
}
return main_ctx;
}
};
// 辅助类用于保存主上下文 struct MainContext { static ucontext_t& get() { return Coroutine::get_main_context(); } };
// 测试协程函数 void task1() { std::cout
void task2() { std::cout
使用方式：
int main() {
Coroutine co1(task1);
Coroutine co2(task2);
<pre class="brush:php;toolbar:false;">while (!co1.done() || !co2.done()) {
if (!co1.done()) co1.resume();
if (!co2.done()) co2.resume();
}
return 0;
}
输出：
Task 1: Step 1
Task 2: Hello
Task 1: Step 2
Task 2: World
C++20 原生协程简介
C++20引入了语言级别的协程支持，关键字包括co_await、co_yield、co_return。要使函数成为协程，其返回类型必须满足协程 traits。
例如，定义一个简单的 generator：
#include <coroutine>
#include <iostream>
<p>struct Generator {
struct promise_type {
int current_value = 0;
std::suspend_always yield_value(int value) {
current_value = value;
return {};
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
Generator get_return_object() { return Generator{this}; }
void return_void() {}
void unhandled_exception() {}
};</p><pre class="brush:php;toolbar:false;">using handle_type = std::coroutine_handle<promise_type>;
handle_type coro;
explicit Generator(promise_type* p) : coro(handle_type::from_promise(*p)) {}
~Generator() { if (coro) coro.destroy(); }
int value() const { return coro.promise().current_value; }
bool move_next() {
if (!coro.done())
coro.resume();
return !coro.done();
}
};
Generator fibonacci() { int a = 0, b = 1; while (true) { co_yield b; int tmp = a + b; a = b; b = tmp; } }
调用：
auto gen = fibonacci();
for (int i = 0; i < 10; ++i) {
gen.move_next();
std::cout << gen.value() << " ";
}
总结与注意事项
手动实现协程库能加深对执行流控制和栈管理的理解。ucontext虽然方便，但在现代系统中不推荐用于生产环境。真正的高性能协程库（如Boost.Context）使用汇编直接操作寄存器。
C++20协程更安全且标准化，适合实际项目。但调试复杂，编译器支持需注意。理解底层机制有助于写出高效、正确的异步代码。
基本上就这些。掌握上下文切换原理，才能真正驾驭异步编程模型。
