C++协程
协程概念
协程是一个可以暂停执行以便稍后恢复的函数。
协程是无堆栈的：通过返回给调用者来暂停执行，并且恢复执行所需的数据与堆栈分开存储。
这允许异步执行顺序的代码（例如，在没有显式回调的情况下处理非阻塞 I/O），并且还支持惰性计算无限序列和其他用途的算法。
如果函数的定义执行以下任何一项，则该函数是协程：
1、使用 co_await 运算符暂停执行直到恢复
task<> tcp_echo_server()
{
char data[1024];
while(true)
{
size_t n = co_await socket.async_read_some(buffer[data]);
co_await async_write(socket,buffer(data,n));
}
}2、使用关键字 co_yield 暂停执行返回值
generator itoa(int n = 0)
{
while(true)
{
co_yield n++;
}
} 3、使用关键字 co_return 完成执行返回值
lazy f()
{
co_return 7;
} 每个协程都必须具有满足许多要求的返回类型，如下所述：
限制
协程不能使用可变参数、普通返回语句或占位符返回类型（auto 或 Concept）。
constexpr 函数、构造函数、析构函数和主函数不能是协程。
执行
每个协程都与
a、从协程内部操纵的承诺对象。 协程通过此对象提交其结果或异常。
b、协程句柄，从协程外部操作。 这是一个非拥有句柄，用于恢复协程的执行或销毁协程框架。
c、协程状态，它是一个内部的堆分配（除非分配被优化），对象包含
1）承诺（promise）对象
2）参数（全部按值复制）
3）当前暂停点的某种表示，以便 resume 知道在哪里继续， destroy 知道哪些局部变量在范围内
4）生命周期跨越当前挂起点的局部变量和临时变量
当协程开始执行时，它会执行以下操作：
1、使用 operator new 分配协程状态对象（见下文）
2、将所有函数参数复制到协程状态：移动或复制按值复制参数，按引用参数保持引用（如果在引用对象的生命周期结束后恢复协程，则可能会变得悬空）
#include
#include
struct promise;
struct coroutine : std::coroutine_handle
{ using promise_type = struct promise; };
struct promise {
coroutine get_return_object()
{ return {coroutine::from_promise(*this)}; }
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
struct S {
int i;
coroutine f() {
std::cout << i;
co_return;
}
};
void bad1() {
coroutine h = S{0}.f();
// S{0} destroyed
h.resume(); // resumed coroutine executes std::cout << i, uses S::i after free
h.destroy();
}
coroutine bad2() {
S s{0};
return s.f(); // returned coroutine can't be resumed without committing use after free
}
void bad3() {
coroutine h = [i = 0]() -> coroutine { // a lambda that's also a coroutine
std::cout << i;
co_return;
}(); // immediately invoked
// lambda destroyed
h.resume(); // uses (anonymous lambda type)::i after free
h.destroy();
}
void good() {
coroutine h = [](int i) -> coroutine { // make i a coroutine parameter
std::cout << i;
co_return;
}(0);
// lambda destroyed
h.resume(); // no problem, i has been copied to the coroutine frame as a by-value parameter
h.destroy();
} 3、调用 promise 对象的构造函数。 如果 Promise 类型有一个接受所有协程参数的构造函数，则调用该构造函数，并带有复制后的协程参数。 否则调用默认构造函数。
4、调用 promise.get_return_object() 并将结果保存在局部变量中。 当协程第一次挂起时，该调用的结果将返回给调用者。 任何在此步骤之前（包括该步骤）引发的异常都会传给调用者，而不是放在 Promise 中。
5、调用 promise.initial_suspend() 并 co_await 其结果。 典型的 Promise 类型要么返回一个 suspend_always，用于延迟启动的协程，要么返回一个 suspend_never，用于急切启动的协程。
6、当 co_await promise.initial_suspend() 恢复时，开始执行协程主体。
7、当协程到达暂停点时，如果需要，在隐式转换为协程的返回类型后，将之前获得的返回对象返回给调用者/恢复者。
8、当协程到达 co_return 语句时，它会执行以下操作：
1）调用 promise.return_void() 为
a、co_return;
b、co_return expr 其中 expr 的类型为 void
c、从返回 void 的协程的末尾掉落。 在这种情况下，如果 Promise 类型没有 Promise::return_void() 成员函数，则行为未定义。
2）或为 co_return expr 调用 promise.return_value(expr)，其中 expr 具有非 void 类型
3）以与创建时相反的顺序销毁所有具有自动存储持续时间的变量。
4）调用 promise.final_suspend() 并 co_await 其结果。
9、如果协程以未捕获的异常结束，它将执行以下操作：
1）捕获异常并从 catch-block 中调用 promise.unhandled_exception()
2）调用 promise.final_suspend() 并 co_await 结果（例如，恢复协程或获取结果）。 从这一点恢复协程是未定义的行为。
10、当协程状态因为 co_return 或未捕获的异常终止，或者因为它的句柄被销毁而被销毁时，它会执行以下操作：
1）调用 promise 对象的析构函数。
2）调用函数参数副本的析构函数。
3）调用 operator delete 释放协程状态使用的内存
4）将执行转移给调用者/resumer。
堆分配
协程状态通过非数组 operator new 在堆上分配。
如果 Promise 类型定义了类级别的替换，则将使用它，否则将使用全局的 operator new。
如果 Promise 类型定义了一个带有附加参数的 operator new 的放置形式，并且它们匹配一个参数列表，其中第一个参数是请求的大小（类型为 std::size_t），其余的是协程函数参数，这些参数将 传递给 operator new（这使得协程可以使用前导分配器约定）。
可以优化对 operator new 的调用（即使使用自定义分配器），如果协程状态的生命周期严格嵌套在调用者的生命周期内，并且协程框架的大小在调用站点是已知的。在这种情况下，协程状态嵌入在调用者的堆栈帧中（如果调用者是普通函数）或协程状态（如果调用者是协程）
如果分配失败，协程抛出 std::bad_alloc，除非 Promise 类型定义了成员函数 Promise::get_return_object_on_allocation_failure()。 如果定义了该成员函数，则分配使用 operator new 的 nothrow 形式，并且在分配失败时，协程立即将从 Promise::get_return_object_on_allocation_failure() 获得的对象返回给调用者。
Promise
Promise 类型由编译器使用 std::coroutine_traits 根据协程的返回类型确定。
形式上，令 R 和 Args... 分别表示协程的返回类型和参数类型列表，Class T 和 /*cv-qual*/（如果有）分别表示协程所属的类类型及其 cv-qualification。如果它被定义为非静态成员函数，它的 Promise 类型由以下决定：
1、std::coroutine_traits
2、std::coroutine_traits
3、std::coroutine_traits
例如：
1、如果协程定义为 task
2、如果协程定义为 task
3、如果协程定义为 task
co_await
unary operator co_await 挂起协程并将控制权返回给调用者。 它的操作数是一个表达式，其类型必须要么定义 operator co_await，要么可以通过当前协程的 Promise::await_transform 转换为这种类型。
co_await expr
首先，将 expr 转换为可等待对象，如下所示：
1、如果 expr 由初始挂起点、最终挂起点或 yield 表达式产生，则awaitable是 expr。
2、否则，如果当前协程的 Promise 类型有成员函数 await_transform，那么 awaitable 就是 promise.await_transform(expr)。
3、否则，awaitable 就是 expr
然后，得到awaiter对象，如下：
1、如果 operator co_await 的重载决议给出了单个最佳重载，则awaiter是该调用的结果（对于成员重载，awaitable.operator co_await()，对于非成员重载，operator co_await(static_cast
2、否则，如果重载决议没有找到 operator co_await，则awaiter是可等待的。
3、否则，如果重载决议不明确，则程序格式错误。
如果上面的表达式是纯右值，则 awaiter 对象是它的临时物化对象。 否则，如果上面的表达式是一个泛左值，那么 awaiter 对象就是它所引用的对象。
然后，调用 awaiter.await_ready() （如果知道结果已准备好或可以同步完成，这是避免挂起成本的捷径）。 如果其结果，上下文转换为 bool 为假，则协程被挂起（其协程状态由局部变量和当前挂起点填充）。
awaiter.await_suspend(handle) 被调用，其中 handle 是表示当前协程的协程句柄。 在该函数内部，挂起的协程状态可以通过该句柄观察到，并且该函数有责任安排它在某个执行程序上恢复或被销毁（返回错误计数作为调度）
1、如果 await_suspend 返回 void，则立即将控制权返回给当前协程的调用者/恢复者（此协程保持挂起状态）。
2、如果 await_suspend 返回布尔值，值 true 将控制权返回给当前协程的调用者/恢复者；值 false 恢复当前协程。
3、如果 await_suspend 返回某个其他协程的协程句柄，则恢复该句柄（通过调用 handle.resume()）（注意这可能会链接到最终导致当前协程恢复）
4、如果 await_suspend 抛出异常，则捕获异常，恢复协程，立即重新抛出异常
最后，调用 awaiter.await_resume() （无论协程是否挂起），其结果是整个 co_await expr 表达式的结果。
如果协程在 co_await 表达式中被挂起，然后又被恢复，那么恢复点就在调用 awaiter.await_resume() 之前。
注意，由于协程在进入 awaiter.await_suspend() 之前已完全挂起，因此该函数可以自由地跨线程传输协程句柄，而无需额外同步。例如，它可以将其放入回调中，计划在异步I/O操作完成时在线程池上运行。在这种情况下，由于当前协同路由可能已经恢复，因此执行了waiter对象的析构函数，当await_suspend()继续在当前线程上执行时，await_suspend()应将*this视为已销毁，并且在句柄发布到其他线程后不访问它。
Example
#include
#include
#include
#include
auto switch_to_new_thread(std::jthread& out) {
struct awaitable {
std::jthread* p_out;
bool await_ready() { return false; }
void await_suspend(std::coroutine_handle<> h) {
std::jthread& out = *p_out;
if (out.joinable())
throw std::runtime_error("Output jthread parameter not empty");
out = std::jthread([h] { h.resume(); });
// Potential undefined behavior: accessing potentially destroyed *this
// std::cout << "New thread ID: " << p_out->get_id() << '\n';
std::cout << "New thread ID: " << out.get_id() << '\n'; // this is OK
}
void await_resume() {}
};
return awaitable{&out};
}
struct task{
struct promise_type {
task get_return_object() { return {}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
};
task resuming_on_new_thread(std::jthread& out) {
std::cout << "Coroutine started on thread: " << std::this_thread::get_id() << '\n';
co_await switch_to_new_thread(out);
// awaiter destroyed here
std::cout << "Coroutine resumed on thread: " << std::this_thread::get_id() << '\n';
}
int main() {
std::jthread out;
resuming_on_new_thread(out);
} Possible output:
Coroutine started on thread: 140193066129216
New thread ID: 140193045907200
Coroutine resumed on thread: 140193045907200注意：awaiter 对象是协程状态的一部分（作为一个临时对象，其生命周期跨越一个暂停点），并在 co_await 表达式完成之前被销毁。 它可用于根据某些异步 I/O API 的要求维护每个操作的状态，而无需求助于额外的堆分配。
标准库定义了两个简单的等待项：std::suspend_always 和 std::suspend_never。
co_yield
Yield-expression 向调用者返回一个值并暂停当前协程：它是可恢复生成器函数的通用构建块
co_yield expr
co_yield braced-init-list 它相当于
co_await promise.yield_value(expr)典型的生成器的 yield_value 会将其参数存储（复制/移动或仅存储其地址，因为参数的生命周期跨越 co_await 内的暂停点）到生成器对象中并返回 std::suspend_always，将控制权转移给调用者/恢复者。
#include
#include
#include
template
struct Generator {
struct promise_type;
using handle_type = std::coroutine_handle;
struct promise_type { // required
T value_;
std::exception_ptr exception_;
Generator get_return_object() {
return Generator(handle_type::from_promise(*this));
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void unhandled_exception() { exception_ = std::current_exception(); } // saving
// exception
template From> // C++20 concept
std::suspend_always yield_value(From &&from) {
value_ = std::forward(from); // caching the result in promise
return {};
}
void return_void() {}
};
handle_type h_;
Generator(handle_type h) : h_(h) {}
~Generator() { h_.destroy(); }
explicit operator bool() {
fill();
/*
唯一可靠地确定我们是否完成协程，是否将通过 C++ getter（下面的operator()）在协程中生成下
一个值（co_yield）的唯一方法是执行/恢复协程，直到下一个 co_yield 点（或让它脱落）。然后
我们存储/缓存结果以承诺允许getter（下面的operator（）在不执行协程的情况下获取它）。
*/
return !h_.done();
}
T operator()() {
fill();
full_ = false; // 我们将移出先前缓存的结果以使 promise 再次为空
return std::move(h_.promise().value_);
}
private:
bool full_ = false;
void fill() {
if (!full_) {
h_();
if (h_.promise().exception_)
std::rethrow_exception(h_.promise().exception_);
// 在被调用的上下文中传播协程异常
full_ = true;
}
}
};
Generator
fibonacci_sequence(unsigned n)
{
if (n==0)
co_return;
if (n>94)
throw std::runtime_error("Too big Fibonacci sequence. Elements would overflow.");
co_yield 0;
if (n==1)
co_return;
co_yield 1;
if (n==2)
co_return;
uint64_t a=0;
uint64_t b=1;
for (unsigned i = 2; i < n; i++)
{
uint64_t s=a+b;
co_yield s;
a=b;
b=s;
}
}
int main()
{
try {
auto gen = fibonacci_sequence(10); // max 94 before uint64_t overflows
for (int j=0; gen; j++)
std::cout << "fib("< Output:
fib(0)=0
fib(1)=1
fib(2)=1
fib(3)=2
fib(4)=3
fib(5)=5
fib(6)=8
fib(7)=13
fib(8)=21
fib(9)=34