purecpp - a cool open source modern c++ community

协程那些事儿（五）--理解co_await

编辑时间：2022-03-11 13:03:00 作者：qicosmos 2条评论

出自：purecpp.cn

转载请注明出处！

和co_await相关的概念有：co_await操作符, awaitable, awaiter, 从名字上看都有await，看得眼晕，傻傻分不清楚。没关系，一步步来看，看完本文之后你就能理解这些概念了。

# co_await的基本语义
```c++
co_await expr
```
co_await操作符是c++20新增的一个关键字, co_await expr表示等待一个惰性求值的任务，这个任务可能在某个线程执行，也可能在OS内核执行，什么时候执行结束不知道，我们又不希望这个task阻塞调用者，所以就可以借助co_await把协程挂起并返回到caller，caller可以继续做事情，不会因为这个task而阻塞。当任务完成之后co_await就会返回协程的结果。

![img](http://purecpp.cn/static/ccaf3423cc234cac8317eec29b979698.png)

所以co_wait主要有两个作用：挂起协程和获取协程的返回值。

co_await等待一个task的时候不阻塞调用者，这正是协程化异步编程模型为同步编程模型的关键。

# co_await的秘密
co_await操作符在概念上和函数调用符是类似的，当一个对象有函数调用符就认为它是一个函数对象即callable，当某个对象“支持”co_wait操作符时，那么它就是一个awaitable，是不是和callable的概念是类似的，似乎顿悟！

接下来看co_await后面的expr是什么。co_await后面的expr被称为awaitable，让我们来看两个最简单的awaitable：
```c++
std::suspend_always
```
```co_await std::suspend_never;```会发生什么?写个测试代码:
```c++
void test() {
  co_await std::suspend_always{};
}
```
你会得到一个编译错误提示缺少promise_type，为什么？之前已经介绍过，co_await必须在一个协程中，协程创建时需要创建promise_type，再通过promise对象返回一个内外通信的对象，如果忘记了回过头看之前的文章吧。

修改一下代码：

```c++
struct task {
  struct promise_type {
    task get_return_object() { return { std::coroutine_handle<task::promise_type>::from_promise(*this) }; }
    std::suspend_never initial_suspend() { return {}; }
    std::suspend_never final_suspend() noexcept { return {}; }
    void return_void() {}
    void unhandled_exception() {}
  };

std::coroutine_handle<task::promise_type> handle_;
};

task test() {
  co_await std::suspend_always{};
}
```

```co_await std::suspend_always{};```会被编译器转换成一个模板框架代码：

```c++
{
  auto&& value = std::suspend_always{};
  auto&& awaitable = get_awaitable(promise, static_cast<decltype(value)>(value));
  auto&& awaiter = get_awaiter(static_cast<decltype(awaitable)>(awaitable));
  if (!awaiter.await_ready())
  {
    using handle_t = std::experimental::coroutine_handle<P>;

using await_suspend_result_t =
      decltype(awaiter.await_suspend(handle_t::from_promise(p)));

<suspend-coroutine>

if constexpr (std::is_void_v<await_suspend_result_t>)
    {
      awaiter.await_suspend(handle_t::from_promise(p));
      <return-to-caller-or-resumer>
    }
    else
    {
      static_assert(
         std::is_same_v<await_suspend_result_t, bool>,
         "await_suspend() must return 'void' or 'bool'.");

if (awaiter.await_suspend(handle_t::from_promise(p)))
      {
        <return-to-caller-or-resumer>
      }
    }

<resume-point>
  }

return awaiter.await_resume();
}
```
这个模板框架代码先获取表达式的值，然后根据它来获取awaitable, get_awaitable的伪代码:
```c++
template<typename P, typename T>
decltype(auto) get_awaitable(P& promise, T&& expr)
{
  if constexpr (has_any_await_transform_member_v<P>)
    return promise.await_transform(static_cast<T&&>(expr));
  else
    return static_cast<T&&>(expr);
}
```
如果协程的promise中定义了await_transform，那么就调用await_transform来得到awaitable，否则就把自己作为awaitable返回, 这里，我们没有在task里面定义await_transform，因此std::suspend_always将作为awaitable, 它的实现代码：
```c++
struct suspend_always {
    constexpr bool await_ready() const noexcept {
        return false;
    }

constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
};
```

在获取了awaitable对象std::suspend_always后，再根据它来获取awaiter，get_awaiter的伪代码：
```c++
template<typename Awaitable>
decltype(auto) get_awaiter(Awaitable&& awaitable)
{
  if constexpr (has_member_operator_co_await_v<Awaitable>)
    return static_cast<Awaitable&&>(awaitable).operator co_await();
  else if constexpr (has_non_member_operator_co_await_v<Awaitable&&>)
    return operator co_await(static_cast<Awaitable&&>(awaitable));
  else
    return static_cast<Awaitable&&>(awaitable);
}
```
这个get_awaiter的返回值就是awaiter，它的实现有3个分支：如果awaitable有co_await操作符，就调用它的co_await操作符来返回awaiter；如果它没有co_await操作符就调用全局的co_await操作符，看看awaitable能否被全局的co_await调用，如果能调用就调用全局的co_await操作符来返回awaiter；如果都没有，那么就直接将awaitable作为awaiter返回出去。

等等，什么是awaiter？刚了解了awaitable，又来一个awaiter！awaiter是awaitable返回的对象，它有可能返回的是自己，所以一个awaitable还可以是一个awaiter。

你可能会问为什么需要这个awaiter，不能直接用awaitable吗？多搞一个概念太绕了。我个人觉得原因有两点：
1. 通过一个专门的带有约束的对象来实现协程挂起和获取协程返回值；
2. 灵活性和扩展性，awaitable可以作为一个间接层，保存一些co_await的上下文，便于做更多事情。

通过模板框架代码可以看到awaiter必须存在：await_ready, await_suspend和await_resume三个操作符。

如果awaiter.await_ready()返回false就挂起协程，接着调用awaiter.await_suspend，如果await_suspend返回void或者true，那就返回到caller，如果返回false就执行协程函数中co_await下面的语句；如果awaiter.await_ready()返回true说明协程已经执行完了，这时候调用awaiter.await_resume返回协程的结果。

接下来我们通过一个简单的例子来展示co_await过程：
```c++
struct task {
  struct promise_type {
    task get_return_object() { return { std::coroutine_handle<task::promise_type>::from_promise(*this) }; }
    std::suspend_never initial_suspend() { return {}; }
    std::suspend_never final_suspend() noexcept { return {}; }
    void return_void() {
      std::cout << "get coroutine result\n";
    }
    void unhandled_exception() {}
  };

std::coroutine_handle<task::promise_type> handle_;
};

task test() {
  std::cout << "create a coroutine\n";
  co_await std::suspend_always{};
  std::cout << "this is the resume point\n";
}
int main() {
  auto t = test();
  std::cout << "return to caller now\n";
  std::cout << "the caller resumes the suspended coroutine\n";
  t.handle_();
  std::cout << "coroutine destroyed\n";
}
```
输出：
```
create a coroutine
return to caller now
the caller resumes the suspended coroutine
this is the resume point
get coroutine result
coroutine destroyed
```
读者可以自定义一个awaiter，然后通过控制awaiter的await_ready和await_suspend来控制协程。

这里要专门提一下awaiter的await_suspend方法，一般在await_suspend中发起一个异步操作，这时候协程是挂起的，返回到调用者，不阻塞调用者，当异步操作完成之后再恢复协程将协程的返回值通过await_resume返回出去，co_await结束，调用者拿到co_await返回的结果。这是使用co_await比较关键的地方。

到目前为止还只介绍了co_await的基本概念和基本流程，还没看到co_await的应用，将在下一篇文章中重点介绍co_await的应用和它的“魔法”。

co_await机制确实有点难懂，概念也比较多，写了这么多不知道大家看懂了没有，如果看懂了也不枉费我的一番心血，如果没看懂也没关系，因为我们已经提供了简单易用的协程库[async_simple](https://github.com/alibaba/async_simple)，学会async_simple就可以了。

来说两句吧