c++20 协程本质

c++20 协程本质

背景：

最近因项目关系，web端，js异步调用，发现跟本门的C++20 还是有些不一样的，本文主要从另外一个角度来看

什么是协程

协程是能暂停执行以在之后恢复的函数。协程是无栈的：它们通过返回到调用方暂停执行，并且恢复执行所需的数据与栈分离存储。这样就可以编写异步执行的顺序代码（例如不使用显式的回调来处理非阻塞输入/输出），还支持作用于惰性计算的无限序列上的算法及其他用途。

腾讯用c语言实现了一个有栈携程，libco，有兴趣的同学可以看下，跟本文讲的协程不太一样。

当一个函数中出现 co_yeild, co_wait, co_return，它就是一个协程

了解一些概念

承诺（promise）对象，从协程内部操纵。协程通过此对象提交其结果或异常。

协程句柄 (coroutine handle)，从协程外部操纵。这是用于恢复协程执行或销毁协程帧的非拥有柄

co_yeild, co_wait, co_return ,可以参照https://zh.cppreference.com/w/cpp/language/coroutines里边自行看下，

我们主要分析协程在编译后会变成什么样子

示例代码

C++ #include #include #include #include struct Generator {   class ExhaustedException : std::exception {};   struct promise_type {     int value;     bool is_ready = false;     std::suspend_always initial_suspend() { return {}; };     std::suspend_always final_suspend() noexcept { return {}; }     std::suspend_always yield_value(int value) {       this->value = value;       is_ready = true;       return {};     }     void unhandled_exception() {     }     Generator get_return_object() {       return Generator{std::coroutine_handle::from_promise(*this)};     }     void return_void() {}   };   std::coroutine_handle handle;   bool has_next() {     if (handle.done()) {       return false;     }     if (!handle.promise().is_ready) {       handle.resume();     }     if (handle.done()) {       return false;     } else {       return true;     }   }   int next() {     if (has_next()) {       handle.promise().is_ready = false;       return handle.promise().value;     }   }   explicit Generator(std::coroutine_handle handle) noexcept       : handle(handle) {}     ~Generator() {     if (handle) handle.destroy();   } }; Generator fibonacci() {   co_yield 0;   co_yield 1;   int a = 0;   int b = 1;   while (true) {     co_yield a + b;     b = a + b;     a = b - a;   } } int main() {   auto generator = fibonacci();   for (int i = 0; i < 10; ++i) {     if (generator.has_next()) {       std::cout << generator.next() << " " << std::endl;     } else {       break;     }   }   return 0; }

原示例很简单，斐波那契数列，考虑以下问题：

上文中的fibonacci方法中，int a; int b 存在哪里，是栈空间还是堆空间

为什么fibonacci方法返回的Generator里边会定义struct promise_type 内部结构体

协程的帧到底长什么样子的

协程挂起与恢复的本质是什么

带着上边疑问，接下来就开始分析下，编译器把这块代码转成什么样子的

C++ struct __fibonacciFrame {   void (*resume_fn)(__fibonacciFrame *);   void (*destroy_fn)(__fibonacciFrame *);   std::__coroutine_traits_impl::promise_type __promise;   int __suspend_index;   bool __initial_await_suspend_called;   int a;   int b;   std::suspend_always __suspend_71_11;   std::suspend_always __suspend_72_3;   std::suspend_always __suspend_73_3;   std::suspend_always __suspend_78_5;   std::suspend_always __suspend_71_11_1; }; Generator fibonacci() {   /* Allocate the frame including the promise */   __fibonacciFrame * __f = reinterpret_cast<__fibonacciFrame *>(operator new(__builtin_coro_size()));   __f->__suspend_index = 0;   __f->__initial_await_suspend_called = false;      /* Construct the promise. */   new (&__f->__promise)std::__coroutine_traits_impl::promise_type{};      /* Forward declare the resume and destroy function. */   void __fibonacciResume(__fibonacciFrame * __f);   void __fibonacciDestroy(__fibonacciFrame * __f);      /* Assign the resume and destroy function pointers. */   __f->resume_fn = &__fibonacciResume;   __f->destroy_fn = &__fibonacciDestroy;      /* Call the made up function with the coroutine body for initial suspend.      This function will be called subsequently by coroutine_handle<>::resume()      which calls __builtin_coro_resume(__handle_) */   __fibonacciResume(__f);         return __promise.get_return_object(); } /* This function invoked by coroutine_handle<>::destroy() */ void __fibonacciDestroy(__fibonacciFrame * __f) {   /* destroy all variables with dtors */   __f->~__fibonacciFrame();   /* Deallocating the coroutine frame */   operator delete(__builtin_coro_free(static_cast(__f))); }

方便分析，上边代码已经删除了一部分，首先我们先回答第一个问题，这两个变量存放位置，

struct __fibonacciFrame 里边有int a; int b;两个成员，在fibonacci()，可以看到使用了new 关键字分配对象，也就是说int a；int b；被编译器放到堆里边了，

第二个问题：

为什么要定义struct promise_type，通过上边的代码也可以看出来， new (&__f->__promise) std::__coroutine_traits_impl::promise_type{}; 萃取机已经明确要求，里边要含有promise_type, 并且这个里边要有明确的几个协程必备的方法定义。另外通过__promise.get_return_object()可以构建Generator 对象，

第三个问题：

协程帧的样子就是struct __fibonacciFrame这个里边定义的，包含协程恢复与销毁的方法

第四个问题：

协程挂起与恢复，本质上讲就是函数调用，可以看下下边代码，协程恢复本质上就是标记一个值，每次调用的时候根据这个值，goto 到指定的代码位置，协程里边局部成员都保存在堆里边了，可以直接使用，

C++ /* This function invoked by coroutine_handle<>::resume() */ void __fibonacciResume(__fibonacciFrame * __f) {   try   {     /* Create a switch to get to the correct resume point */     switch(__f->__suspend_index) {       case 0: break;       case 1: goto __resume_fibonacci_1;       case 2: goto __resume_fibonacci_2;       case 3: goto __resume_fibonacci_3;       case 4: goto __resume_fibonacci_4;     }          /* co_await insights.cpp:71 */     __f->__suspend_71_11 = __f->__promise.initial_suspend();     if(!__f->__suspend_71_11.await_ready()) {       __f->__suspend_71_11.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());       __f->__suspend_index = 1;       __f->__initial_await_suspend_called = true;       return;     }          __resume_fibonacci_1:     __f->__suspend_71_11.await_resume();          /* co_yield insights.cpp:72 */     __f->__suspend_72_3 = __f->__promise.yield_value(0);     if(!__f->__suspend_72_3.await_ready()) {       __f->__suspend_72_3.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());       __f->__suspend_index = 2;       return;     }          __resume_fibonacci_2:     __f->__suspend_72_3.await_resume();          /* co_yield insights.cpp:73 */     __f->__suspend_73_3 = __f->__promise.yield_value(1);     if(!__f->__suspend_73_3.await_ready()) {       __f->__suspend_73_3.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());       __f->__suspend_index = 3;       return;     }          __resume_fibonacci_3:     __f->__suspend_73_3.await_resume();     __f->a = 0;     __f->b = 1;     while(true) {              /* co_yield insights.cpp:78 */       __f->__suspend_78_5 = __f->__promise.yield_value(__f->a + __f->b);       if(!__f->__suspend_78_5.await_ready()) {         __f->__suspend_78_5.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());         __f->__suspend_index = 4;         return;       }              __resume_fibonacci_4:       __f->__suspend_78_5.await_resume();       __f->b = (__f->a + __f->b);       __f->a = (__f->b - __f->a);     }          goto __final_suspend;   } catch(...) {     if(!__f->__initial_await_suspend_called) {       throw ;     }          __f->__promise.unhandled_exception();   }      __final_suspend:      /* co_await insights.cpp:71 */   __f->__suspend_71_11_1 = __f->__promise.final_suspend();   if(!__f->__suspend_71_11_1.await_ready()) {     __f->__suspend_71_11_1.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());   }      ; }

协程恢复就更好理解了，

C++ if(!__f->__suspend_73_3.await_ready()) {       __f->__suspend_73_3.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());       __f->__suspend_index = 3;       return;     }

await_ready return false，就直接进入里边，然后就return了，很好理解

总结：

通过上边的理解，我们可以看到协程本质上还是函数调用，利用goto语句来实现协程挂起与恢复