ROOT
ROOT
文章目录
  1. 使用场景
  2. 概念模型
    1. Promise
    2. Future
    3. Awaitable
  3. 具体机制
    1. Promise/Future 对象
    2. Awaitable 对象
  4. 协程实战
  5. 总结

C++20 协程初探

2020.09.05 Netcan 学习笔记  热度 ℃

C++20 终于引入了协程特性，给库作者提供了一个实现协程的机制，让用户方便使用协程来编写异步逻辑，降低了异步并发编程的难度。结合我最近协程的学习，在这里记录一下相关内容。

使用场景

协程和普通函数相比，多了个中途随时 挂起 ，随后 恢复 的过程，当用户调用一个阻塞请求接口，从而让出控制权，当响应时，恢复之前的控制流，从而大大提高线程复用率，这也注意了协程只是并发的，并不是真正意义上的并行，在 IO 密集型场景下，协程能够很好的提高资源利用率，用少数的线程达到并发成百上万个协程的效果。

而相对传统的线程池 + 回调模式，每发起一个请求，为了避免阻塞当前线程，需要挂一个回调函数处理后续过程，而回调函数又可能产生竞争，导致得加锁处理。而协程却能够以同步方式写实现异步，后续过程直接挂起，当响应的时候恢复执行。

我参与的项目中，对象随时都可能起个线程干活，或者常驻于对象生命周期里，统计下来整个项目居然开了几百个线程，由于多线程编程难免导致竞争，从而需要锁这种很低级的机制做同步，而一旦引入了锁，就不可避免的扩散开来，大家看到这里加把锁，那我也加把锁，统计下来代码里面居然也有几百把锁。。真是维护的噩梦啊🤣

由于协程能够随时挂起，后续恢复，这就能实现一些延迟计算的特性，例如生成器。

扯远了，本文主题是关于 C++20 的协程，在 C++20 还没稳定之前，先来学习一下相关知识，读完本文后你应该能利用这个机制实现一些想要的协程了。

概念模型

C++20 的协程设计为无栈协程，相对于有栈协程，省掉了上下文切换开销[1]，只能手动切换，效率更高，也不用管理复杂的寄存器状态，移植性更好，但这同时也导致了不能被非协程函数嵌套调用。

同时引入了 3 个关键字：

  • co_yield: 挂起并返回值
  • co_await: 挂起
  • co_return: 结束协程

当一个函数出现了上面的关键字，则该函数是个协程。

Promise

当 caller 调用一个 callee 协程的时候，协程自身的状态信息 [2]（形参，局部变量，自带数据，各个阶段点执行点）会被保存在堆上的 Promise 对象中，这也是编译器会在协程里面插入 Promise 相关代码，以及一些执行点。由于 Promise 的大小可以在编译期计算出来，从而避免了内存浪费。而 Promise 对象所有权可由coroutine_handle 句柄持有。

Future

而 Future 对象主要是与 Promise 对象交互的桥梁，既 caller 与 callee 之间的通信：

  • callee 挂起时，将值返回给 caller: yield 语义
  • callee 执行结束时，将值返回给 caller: return 语义
  • callee 恢复时，caller 将值带给 callee

需要注意的是，这些概念和标准库的 std::promise/std::future 不是同一个东西，后者用于做同步用，std::future会阻塞等待直到 std::promise 提供值，可以看做是条件变量的封装，同样地，和其他语言的 Promise/Future 概念也不一样。

Awaitable

如果一个对象是 Awaitable 对象，那么可以用 co_await 操作符去触发该对象的动作 ready/suspend/resume，从而转移、恢复控制权，co_await 细节留到后面在介绍。

具体机制

了解了概念模型后，我们可以进一步探讨背后的机制了。

Promise/Future 对象

当一个协程被调用时，会创建 Promise 对象，然后编译器会在各个阶段插入一些代码[3]：

{
  co_await promise.initial_suspend();
  try
  {
    <body-statements>
  }
  catch (...)
  {
    promise.unhandled_exception();
  }
FinalSuspend:
  co_await promise.final_suspend();
}

可以看到一个协程函数，分为如下几个步骤：

  1. 从堆上 (operator new) 创建 Promise 对象，保存协程的状态信息
  2. initial_suspend 阶段，用于在执行协程主体 <body-statements> 代码前做些事情
  3. <body-statements>阶段，执行协程的主体代码
  4. unhandled_exception 阶段，若抛异常，处理异常
  5. final_suspend 阶段，协程结束收尾动作，在这阶段的 coroutine_handle<Promise>::done 方法为 true，caller 可以通过这个方法判断协程是否结束，从而不再调用 resume 恢复协程

而协程返回类型则是一个 Future 对象，这一步编译器通过 Promise::get_return_object() 来创建 Future 对象。而 Future 对象一般持有 Promise 的句柄：coroutine_handle<Promise>，这样 caller 可以通过 Future 与 Promise 交互，从而恢复协程。

而 Promise 对象释放的时间点有两个，避免重复执行，否则会 double free：

  • final_suspend 阶段 resume 后
  • 调用 coroutine_handle<Promise>::destroy() 方法

比较好的做法是在 final_suspend 阶段挂起，这时候就不可 resume 了，在 caller 通过调用 Future 持有的句柄 destroy() 方法释放 Promise 对象。

综上，一个 Promise 对象需要实现如下方法：

  • initial_suspend: 返回一个 Awaitable 对象
  • final_suspend: 返回一个 Awaitable 对象
  • get_return_object: 返回一个 Future 对象给 caller
  • unhandled_exception: 处理异常
  • return_value/return_void: co_return 时返回值给 caller
  • yield_value: 挂起时返回值给 caller

再来看看其 coroutine_handle<Promise> 句柄编译器提供了哪些主要方法：

  • destroy: 销毁 Promise 对象
  • from_promise: 静态方法，从 Promise 对象返回其 coroutine_handle 句柄
  • done: 是否处于 final_suspend 阶段
  • promise: 返回 Promise 对象引用
  • resume/operator(): 恢复到协程

Awaitable 对象

前面提到的 co_await 关键字[4]，其操作的对象其实是 Awaiter 对象，若对象实现如下方法，则说明该对象是 Awaitable 的：

  • await_ready
  • await_suspend(coroutine_handle<>)
  • await_resume

那么当执行 co_await <expr> 表达式时，编译器会生成如下代码：

{
  auto&& value = <expr>;
  auto&& awaitable = get_awaitable(promise, static_cast<decltype(value)>(value));
  auto&& awaiter = get_awaiter(static_cast<decltype(awaitable)>(awaitable));
  if (!awaiter.await_ready())
  {
    <suspend-coroutine>

    //if await_suspend returns void
    try {
        awaiter.await_suspend(coroutine_handle);
        return_to_the_caller();
    } catch (...) {
        exception = std::current_exception();
        goto resume_point;
    }
    //endif
    //if await_suspend returns bool
    bool await_suspend_result;
    try {
        await_suspend_result = awaiter.await_suspend(coroutine_handle);
    } catch (...) {
        exception = std::current_exception();
        goto resume_point;
    }
    if (not await_suspend_result)
        goto resume_point;
    return_to_the_caller();
    //endif
    //if await_suspend returns another coroutine_handle
    decltype(awaiter.await_suspend(std::declval<coro_handle_t>())) another_coro_handle;
    try {
        another_coro_handle = awaiter.await_suspend(coroutine_handle);
    } catch (...) {
        exception = std::current_exception();
        goto resume_point;
    }
    another_coro_handle.resume();
    return_to_the_caller();
    //endif
  }
  resume_point:
if(exception)
  std::rethrow_exception(exception);
"return" awaiter.await_resume();
}

也就是：

  1. 通过 <expr> 拿到 Awaiter 对象
  2. 通过 Awaiter.await_ready()方法判断是否需要挂起，若为 true 则无需挂起
  3. 判断 Awaiter.await_suspend()的返回值类型：
    • void，无返回值，直接挂起返回 caller
    • bool，若为 true，则返挂起返回 caller，否则不挂起，直接 resume
    • coroutine_handle<>, 则挂起并将控制权转移到另一个协程上，另一个协程可以再 resume 回来，到达resume_point。
  4. Awaiter.await_resume()的返回值即为 co_await 的结果

那么问题来了，谁来创建 Awaiter 对象呢？有两种方法：

  1. 通过 Promise 对象的 await_transform(<expr>) 方法，得到 Awaiter 对象
  2. 通过重载 operator co_await 操作符，得到 Awaiter 对象
  3. 直接用 Awaitable 对象

标准库里面实现了两种 Awaiter，分别如下：

struct suspend_never {
  bool await_ready() const { return true; }
  void await_suspend(coroutine_handle<>) const {}
  void await_resume() const {}
};

struct suspend_always {
  bool await_ready() const { return false; }
  void await_suspend(coroutine_handle<>) const {}
  void await_resume() const {}
};

主要在 await_ready 阶段判断是否需要挂起协程。

最后 co_yield <expr> 其实是 co_await 的语法糖，生成如下代码：

co_await promise.yield_value(expression);

而 co_return 则会调用 Promise 对象的 return_void/return_value 方法。

协程实战

有了以上知识，应该足够实现一些协程了。

为了简单起见，这里我实现一个 Fibonacci 的生成器，完整代码可以见： https://github.com/netcan/recipes/blob/master/cpp/coroutine/FibonacciGen.cpp

首先先写协程函数，并在 main caller 中调用，内容如下：

FiboFuture generate_fibo() {
    int i = 0, j = 1;
    while (true) {
        co_yield j;
        std::tie(i, j) = std::make_pair(j, i + j);
    }
}

int main() {
    for (auto x = generate_fibo(); x < 1000; x.resume())
        std::cout << "fibo:" << x << std::endl;
    return 0;
}

接着实现我们所需要的 Proimse 对象，用于将结果传给 caller：

struct promise_type {
    int value_; // 返回结果给 caller
    auto initial_suspend() { return suspend_never{}; }
    auto final_suspend() noexcept { return suspend_always{}; } // final_suspend 挂起，由 FiboFuture 释放 promise 对象
    FiboFuture get_return_object()
    { return {coroutine_handle<promise_type>::from_promise(*this)}; } // 返回 FiboFuture 对象
    void unhandled_exception() { std::terminate(); }

    auto yield_value(int value) { // yield 一个值并挂起返回 caller
        value_ = value;
        return suspend_always{};
    }
    void return_void() {}
};

还有对应的 Future：

struct FiboFuture {
    struct promise_type;
    FiboFuture(coroutine_handle<promise_type> handle): handle_(handle) {}

    operator int() { return handle_.promise().value_; }
    void resume() { if (! handle_.done()) handle_.resume(); }
    ~FiboFuture() { handle_.destroy(); }
private:
    coroutine_handle<promise_type> handle_;
};

一切搞定，这就是目前生成器的实现，待后续集成到标准库中去，方便使用。

还有一个例子是 caller/callee 相互协作，互相通信完成任务，具体见： https://github.com/netcan/recipes/blob/master/cpp/coroutine/DoubleClick.cpp

总结

期待 C++20 协程的稳定成熟，这样写业务代码就简单多了，心智负担没那么重了。

  1. 有栈协程与无栈协程 ↩︎

  2. Introduction to C++ Coroutines - James McNellis ↩︎

  3. C++ Coroutines: Understanding the promise type ↩︎

  4. CO_AWAITING COROUTINES ↩︎

支持一下
扫一扫，支持Netcan
  • 微信扫一扫
  • 支付宝扫一扫