前言
前面两节我们已经能够实现一个可用的协程框架了。但我们一定还想更深入的了解协程，于是我们就想尝试下能不能co_await一个协程。下面会涉及到部分模板编程的知识，主要包括（模板偏特化，模板参数列表传值，模板函数类型推断）可以提前了解下，方便后续理解。
在开始之前我们不妨思考下面一些问题：
- 异步函数 和 协程 在co_await时的共性是什么？
两者的操作数都必须是awaiter，这意味着co_await协程,必须能够将协程转换为一个awaiter。- 协程生命周期什么时候结束？协程执行到co_return时，或者执行coroutine_handle.destory()时，以及出现未捕获的异常时会销毁协程，释放协程对象promise
- 协程从开始到结束，会产生几个awaiter，会co_awiter几次？
2~3次，initial_suspend和final_suspend会产生两个awaiter，同时编译器帮我们进行了co_await， 还有一次是人为的co_await,即我们co_await一个协程。- initial_suspend和final_suspend 这两个功能的作用是什么？
为什么要initial_suspend和final_suspend ，或者说为什么这里可以自由返回可挂起的等待体，为什么提供这个机制？initial_suspend是协程创建后，编译器帮我们co_await，这将允许我们即使不使用co_await，协程函数运行能参与到不同于普通函数的调度中，这直接决定了协程行为上和普通函数的相似程度;final_suspend功能也类似，我们已经知道该函数是在协程执行结束时操作系统使用co_await调用的，如果final_suspend返回的是不挂起操作awaiter，那么协程在执行完后会自动析构promise对象释放资源，而返回挂起awaiter，提供了将协程对象销毁交给用户的协程调度器的可能性。这里还有一个知识点，是对第二篇final_suspend的补充，使用协程还可以实现序列发生器，序列发生器中的协程永远不会调用co_return，所以永远不会结束，当final_suspend不挂起时，编译器也无法分辨出一个协程的生命周期，而这里选择挂起，我们可以明确告诉编译器该协程会结束，有助于编译器帮我们优化。
协程代码实现
我的目标是让c++像在python中一样使用协程。
我的协程实现思路如下：我希望协程表现出的行为尽可能和普通函数一样，所以我不在initial_suspend时挂起协程给协程调度器调度（我直接在该返回的awaiter::await_ready返回true，给编译器提供优化协程为inline的机会）；协程应该是和python一样是单线程，所以不会在用户co_await时，交给其他线程处理（这部分功能由上一节异步函数补齐）；我希望编译器尽可能能帮我优化代码而且更符合规范，所以我在协程结束时挂起协程，交给调度器去调度销毁。
代码
#include <coroutine>
#include <future>
#include <chrono>
#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <memory>
#include <vector>
struct async_task_base
{
virtual void completed() = 0;
virtual void resume() = 0;
};
std::mutex m;
std::vector<std::shared_ptr<async_task_base>> g_event_loop_queue;
std::vector<std::shared_ptr<async_task_base>> g_resume_queue; //多线程异步任务完成后后，待主线程恢复的线程
std::vector<std::shared_ptr<async_task_base>> g_work_queue; //执行耗时操作线程队列
enum class EnumAwaiterType:uint32_t{
EnumInitial = 1, //协程initial
EnumSchduling = 2,// 用户co_await
EnumFinal = 3//销毁
};
template <typename ReturnType>
struct CoroutineTask;
template <typename CoTask, EnumAwaiterType AwaiterType >
struct CommonAwaiter ;
template <typename CoTask, EnumAwaiterType AwaiterType>
struct coroutine_task: public async_task_base{
coroutine_task(CommonAwaiter<CoTask, AwaiterType> &awaiter)
:owner_(awaiter)
{
}
void completed() override{
}
void resume() override{
if(owner_.h_.done()){
owner_.h_.destroy();
}else{
owner_.h_.resume();
}
}
CommonAwaiter<CoTask,AwaiterType> &owner_ ;
};
template <typename CoTask, EnumAwaiterType AwaiterType = EnumAwaiterType::EnumSchduling>
struct CommonAwaiter
{
using return_type = typename CoTask::return_type;
using promise_type = typename CoTask::promise_type;
CommonAwaiter(promise_type* promise):promise_(promise){
}
// 当时initial_suspend返回的awaiter时，挂起，直接resume
bool await_ready() const noexcept {
return false;
}
//也可以直接恢复
// std::coroutine_handle<> await_suspend(std::coroutine_handle<> h) {
// return h;
// }
void await_suspend(std::coroutine_handle<> h) {
// std::cout <<"await_suspend()" << std::endl;
h_ = h;
g_event_loop_queue.emplace_back(std::shared_ptr<async_task_base>( new coroutine_task<CoTask, AwaiterType>(*this)) );
}
return_type await_resume() const noexcept {
return promise_->get_value();
}
~CommonAwaiter(){
}
bool resume_ready_= false;
promise_type* promise_ = nullptr;
std::coroutine_handle<> h_ = nullptr;
};
template <typename CoTask>
struct CommonAwaiter<CoTask, EnumAwaiterType::EnumInitial>
{
CommonAwaiter(){
}
// 当时initial_suspend返回的awaiter时，挂起，跳过await_suspend，直接resume,跳过
bool await_ready() const noexcept {
return true;
}
void await_suspend(std::coroutine_handle<>) {
}
void await_resume() const noexcept {
}
~CommonAwaiter(){
}
};
// 必须为noexcept，因为这个时候协程已经运行结束，不该有异常产生
template <typename CoTask>
struct CommonAwaiter <CoTask, EnumAwaiterType::EnumFinal>
{
CommonAwaiter(){
}
// 这里不选择true让编译器帮我们自动释放,如果为true编译器不知道什么时候协程结束，无法帮助我们优化
bool await_ready() noexcept {
return false;
}
void await_suspend(std::coroutine_handle<> h) noexcept{
h_ = h;
g_event_loop_queue.emplace_back(std::shared_ptr<async_task_base>( new coroutine_task<CoTask, EnumAwaiterType::EnumFinal>(*this)));
}
// 无需返回
void await_resume() noexcept{
}
std::coroutine_handle<> h_ = nullptr;
};
template<typename CoTask>
struct Promise
{
using return_type = typename CoTask::return_type ;
~Promise(){
// std::cout << "~Promise" << std::endl;
}
CommonAwaiter<CoTask, EnumAwaiterType::EnumInitial> initial_suspend() {
return {};
};
CommonAwaiter<CoTask, EnumAwaiterType::EnumFinal> final_suspend() noexcept {
return {};
}
// 提供了一种对协程中未捕获的异常的再处理，比如将异常保存下来，实现协程如以下形式 ： coroutine().get().catch()
// 这里我们的实现形式决定了，这里直接再次抛出异常就好
void unhandled_exception(){
// try {
std::rethrow_exception(std::current_exception());
// } catch (const std::exception& e) {
// // 输出异常信息
// std::cerr << "Unhandled exception caught in CustomAsyncTask: " << e.what() << std::endl;
// } catch (...) {
// std::cerr << "Unhandled unknown exception caught in CustomAsyncTask!" << std::endl;
// }
}
CoTask get_return_object(){
return CoTask(this);
}
return_type get_value() {
return value_;
}
void return_value(return_type value){
value_ = value;
}
// 该代码写在Promise中的好处是，可以方便阅读代码很容易就能回想出协程最多会返回三个等待体
template<typename T>
CommonAwaiter<CoroutineTask<T>> await_transform(CoroutineTask<T> &&task){
return CommonAwaiter<CoroutineTask<T>>(task.p_);
}
CoTask await_transform(CoTask &&task){
return CommonAwaiter<CoTask>(task.p_);
}
return_type value_;
};
template <typename ReturnType>
struct CoroutineTask{
using return_type = ReturnType;
using promise_type = Promise<CoroutineTask>;
CoroutineTask(const CoroutineTask &other) = delete;
CoroutineTask(const CoroutineTask &&other) = delete;
CoroutineTask& operator=(const CoroutineTask&) = delete;
CoroutineTask& operator=(const CoroutineTask&&) = delete;
CoroutineTask(promise_type* promise) {
p_ = promise;
}
promise_type *p_ = nullptr;
};
CoroutineTask<u_int64_t> second_coroutine(){
co_return 3;
}
CoroutineTask<float> third_coroutine(){
co_return 3.1;
}
CoroutineTask<char> first_coroutine(){
uint64_t num = co_await second_coroutine();
std::cout << "second_coroutine result is : " << num << std::endl;
float num2 = co_await third_coroutine();
std::cout << "third_coroutine result is : " << num2 << std::endl;
co_return 'b';
}
void do_work() {
while (1)
{
std::lock_guard<std::mutex> g(m);
for(auto task : g_work_queue){
task->completed();
g_resume_queue.push_back(task);
}
g_work_queue.clear();
}
}
void run_event_loop(){
std::vector<std::shared_ptr<async_task_base>> g_raw_work_queue_tmp;
std::vector<std::shared_ptr<async_task_base>> g_event_loop_queue_temp;
while(1){
g_raw_work_queue_tmp.clear();
g_event_loop_queue_temp.clear();
{
g_event_loop_queue_temp.swap(g_event_loop_queue);
std::lock_guard<std::mutex> g(m);
g_raw_work_queue_tmp.swap(g_resume_queue);
}
// 优先恢复耗时任务
for(auto &task : g_raw_work_queue_tmp){
task->resume();
}
for(auto task : g_event_loop_queue_temp){
task->resume();
}
}
}
void test_func(){
first_coroutine();
}
int main(){
test_func();
std::thread work_thread(do_work);
run_event_loop();
return 0;
}
代码分析
Promise
unhandled_exception
unhandled_exception 的作用是是用来对协程中未捕获的异常再处理。在一些实现协程使用方式为 **coroutine().get().catch()**的架构中，会把未捕获的异常暂存下来，待恢复的时候再抛出。我选择直接抛出异常，因为出现未捕获的异常时，协程也会提前结束，这时reume的结果是未定义的，所以我觉得在resume之前抛出异常有有必要的。
await_transform
await_transform的作用和重载运算符co_await是一样的，在co_await一个协程时，会转换CoroutineTask为一个awaiter。使用await_transform的优势是，所有等待体的返回时机，都在promise定义出来，方便代码阅读。
这里我们需要注意的是该await_transform需要定义为模板函数，而不能用Promise的类型参数CoTask，作为传入参数类型。
修改代码如下
编译一下，我们发现报错了
这里我们再结合代码理解下
根据报错信息和调用顺序，我们可以得出以下结论：
当前位于CoroutineTask的写成体中，所以对应的promise类型是promise<CoroutineTask>,
这时实例化的await_transform 实际上是 CoroutineTask await_transform (CoroutineTask&&task)，而这时await_transform 操作的是协程second_coroutine，协程类型是CoroutineTask<u_int64_t> 类型不一致，所以会出现上面的报错。
CoroutineTask
协程类CoroutineTask要保存什么？
这里只保存了promise的指针，原因如下:
协程和用户代码交互是通过awaiter对象，由于返回值是通过return_value保存在协程promise中的，我们需要在awaiter从promise获取返回的值，所以需要在awaiter中保存promise的指针，那promise的指针从哪来呢？awaiter是在await_transform中使用CoroutineTask初始化的，而我们又知道CoroutineTask是由promise 调用 get_return_object创建的。所以我们在创建CoroutineTask时，将promise的指针保存进去， 这样awaiter就能够通过CoroutineTask作为中介得到promise的指针啦！
CommonAwaiter
其实讲到这里，CommonAwaiter就没多少能讲的东西了。
awaiter使用偏特化，根据不同枚举，特化了三个版本。来控制协程的基本行为：即创建时不挂起，能够有机会被编译器优化为inline；用户代码挂起能够返回任意co_return返回的值；结束挂起，参与调度销毁。对了还有一个问题协程句柄为什么保存在awaiter中而不是promise中。在我看来awaiter就代表了每个挂起点，所以将couroutine_handle保存在awaiter中，couroutine_handle很小所以不考虑内存开销
运行结果
最后我们运行下代码，完美运行。
这里就不阐述流程了，下一篇会将二、三两节的代码合并起来，集中阐述下流程和汇总下重要的知识点。
