亲宝软件园·资讯

展开

C++20 协程 Coroutines C++20 特性 协程 Coroutines(1)

孙孟越 人气:0
想了解C++20 特性 协程 Coroutines(1)的相关内容吗,孙孟越在本文为您仔细讲解C++20 协程 Coroutines的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:C++20特性协程Coroutines,协程Coroutines,下面大家一起来学习吧。

我们先来介绍一下什么是协程.

一、协程简单介绍

协程和普通的函数 其实差不多. 不过这个 "函数" 能够暂停自己, 也能够被别人恢复.

普通的函数调用, 函数运行完返回一个值, 结束.

协程可以运行到一半, 返回一个值, 并且保留上下文. 下次恢复的时候还可以接着运行, 上下文 (比如局部变量) 都还在.

这就是最大的区别.

二、协程的好处

考虑多任务协作的场景. 如果是线程的并发, 那么大家需要抢 CPU 用, 还需要条件变量/信号量或者上锁等技术, 来确保正确的线程正在工作.

如果在协程中, 大家就可以主动暂停自己, 多个任务互相协作. 这样可能就比大家一起抢 CPU 更高效一点, 因为你能够控制哪个协程用上 CPU.

一个例子:

生产者/消费者模型: 生产者生产完毕后, 暂停自己, 把控制流还给消费者. 消费者消费完毕后, resume 生产者, 生产者继续生产. 这样循环往复.

异步调用: 比如你要请求网络上的一个资源.

理想状态下, 4 可以直接用上资源, 这样就完全不浪费时间.

如果是同步的话:

明显需要多等待一会儿. 如果需要发送上百个请求, 那显然是第一种异步调用快一点. (等待的过程中可以发送新的请求)

如果没有协程的话, 解决方案之一是使用多线程. 像这样:

然后通知的办法就有 promise 和回调这些办法.

三、协程得用法

我们照着 C++20 标准来看看怎么用协程. 用 g++, 版本 10.2 进行测试.

目前 C++20 标准只加入了协程的基本功能, 还没有直接能上手用的类. GCC 说会尽量与 clang MSVC 保持协程的 ABI 兼容, 同时和 libc++ 等保持库的兼容. 所以本文可能也适用于它们.

协程和主程序之间通过 promise 进行通信. promise 可以理解成一个管道, 协程和其调用方都能看得到.

以前的 std::async std::future 也是基于一种特殊的 promise 进行通信的, 就是 std::promise. 如果要使用协程, 则需要自己实现一个全新的 promise 类, 原理上是类似的.

四、协程三个关键字

这次引入了三个新的关键字 co_await, co_yield, co_return . 从效果上看: co_await 是用来暂停和恢复协程的, 并且真正用来求值.

co_yield 是用来暂停协程并且往绑定的 promise 里面 yield 一个值.

co_return 是往绑定的 promise 里面放入一个值.

这里我们先谈谈 co_yield co_return. 谈完这俩再谈谈 co_await 就比较简单.

五、协程工作原理

所以最重要的两个问题就是

上面说了, 一个协程会有一个与之相伴的 promise , 用作信息传递. 一个协程, 效果等同于

{
promise-type promise(promise-constructor-arguments); 
try {
    co_await promise.initial_suspend(); // 创建之后 第一次暂停
    function-body // 函数体
} catch ( ... ) {
    if (!initial-await-resume-called)
    throw; 
    promise.unhandled_exception(); 
}

final-suspend:
co_await promise.final_suspend(); // 最后一次暂停
}

细节, 包括 promise 初始化的参数, 异常的处理等等, 我们留到之后的文章再处理. 所以我们简化成

{
promise-type promise; 

co_await promise.initial_suspend(); 

function-body // 函数体

final-suspend:
co_await promise.final_suspend(); 
}


对于暂停, co_await 那个地方就可以暂停并且交出控制权. 下篇文章我们会详细介绍 co_await.

对于唤醒, 则需要拿到一个 std::coroutine_handle, 对它调用 resume() .

1、co_yield

co_yield 123 做的事情实际上相当于调用了 co_await promise.yield_value(123) . 这个 promise 里面存放了 123 以后, 会告诉 co_await 自己要暂停. 于是 co_await 就在这里停下来, 把控制流还回去.

来看一个标准中的实现范例.

#include <iostream>
#include <coroutine>

struct generator
{
    struct promise_type;
    using handle = std::coroutine_handle<promise_type>;
    struct promise_type
    {
        int current_value;
        static auto get_return_object_on_allocation_failure() { return generator{nullptr}; }
        auto get_return_object() { return generator{handle::from_promise(*this)}; }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() { return std::suspend_always{}; }
        void unhandled_exception() { std::terminate(); }
        void return_void() {}
        auto yield_value(int value)
        {
            current_value = value;
            return std::suspend_always{}; // 这是一个 awaiter 结构, 见第二篇文章
        }
    };
    bool move_next() { return coro ? (coro.resume(), !coro.done()) : false; }
    int current_value() { return coro.promise().current_value; }
    generator(generator const &) = delete;
    generator(generator &&rhs) : coro(rhs.coro) { rhs.coro = nullptr; }
    ~generator() {  if (coro) coro.destroy();   }

private:
    generator(handle h) : coro(h) {}
    handle coro;
};

generator f()
{
    co_yield 1;
    co_yield 2;
}

int main()
{
    auto g = f(); // 停在 initial_suspend 那里
    while (g.move_next()) // 每次调用就停在下一个 co_await 那里
        std::cout << g.current_value() << std::endl;
}

generator 是一个包装类, 持有一个 std::coroutine_handle. 同时它规定了 coroutine_handle 本协程的 promise 是什么样的. (通过 generator::promise_type告知)

coroutine_handle是协程的流程管理者, 由它来管理这个 promise. 而 generator 则是 coroutine_handle 的管理者.

f() 是一个协程. 可以展开成这样的伪代码

{
generator g(handle coro); // 建立句柄和包装类

co_await promise.initial_suspend(); // 创建之后停在这里, 等待被恢复

co_await promise.yield_value(1); // 第一次恢复后就会停在这里
co_await promise.yield_value(2); // 第二次恢复后就会停在这里

final-suspend:
co_await promise.final_suspend(); // 第三次恢复后就会停在这里
}

按照这里的写法, 每一次 promise.yield_value() 之后都会返回一个结构体给 co_await, 告诉 co_await 自己在这里暂停.

然后在主函数处调用 g.move_next() , 进而恢复了协程之后, 协程就会从刚刚暂停的 co_await 那一行恢复运行.

对了, 过了最后的 final_suspend() 以后, 这个协程就会析构掉. 再次恢复协程就会导致 segmentation fault.

g++10 已经提供了协程的支持, 只需要加上 -std=c++20 -fcoroutines -fno-exceptions 即可. 上面这段代码可以在这里编译:

2、co_return

co_return 相当于调用了 promise.return_value() 或者 promise.return_void() 然后跳到 final-suspend 标签那里. 也就是说这个这个协程结束了, 再也无法被恢复了.

而对比 co_yield 调用的是 co_await promise.yield_value(). 他们的区别就是 co_yeild 完了协程继续等着下一次被恢复 , co_return co_return完了协程就结束了. (为了让协程也能像普通函数一样返回)

我们来看一段代码.

#include <iostream>
#include <future>
#include <coroutine>

using namespace std;

struct lazy
{
    struct promise_type;
    using handle = std::coroutine_handle<promise_type>;
    struct promise_type
    {
        int _return_value;
        static auto get_return_object_on_allocation_failure() { return lazy{nullptr}; }
        auto get_return_object() { return lazy{handle::from_promise(*this)}; }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() { return std::suspend_always{}; }
        void unhandled_exception() { std::terminate(); }
        void return_value(int value) { _return_value = value; }
    };
    bool calculate()
    {
        if (calculated)
            return true;
        if (!coro)
            return false;
        coro.resume();
        if (coro.done())
            calculated = true;
        return calculated;
    }
    int get() { return coro.promise()._return_value; }
    lazy(lazy const &) = delete;
    lazy(lazy &&rhs) : coro(rhs.coro) { rhs.coro = nullptr; }
    ~lazy() {  if (coro) coro.destroy(); }

private:
    lazy(handle h) : coro(h) {}
    handle coro;
    bool calculated{false};
};


lazy f(int n = 0)
{
    co_return n + 1;
}

int main()
{
    auto g = f();
    g.calculate(); // 这时才从 initial_suspend 之中恢复, 所以就叫 lazy 了
    cout << g.get();
}

由于这个协程只能被恢复一次, 所以我稍稍修改了一下 lazy 的实现. 可以参考这里:

下一篇C++20 新特性 协程 Coroutines(2)

加载全部内容

相关教程
猜你喜欢
用户评论