C++20协程示例

已于 2023-09-26 17:06:37 修改
阅读量778 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c++20 c++ 协程 Coroutine Promise 线程
于 2023-09-26 16:57:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/izwmain/article/details/133315999
版权

C++20协程示例

认识协程

在C++中，协程就是一个可以暂停和恢复的函数。

包含co_wait、co_yield、co_return关键字的都可以叫协程。

看一个例子：

MyCoroGenerator<int> testFunc(int n)
{
    std::cout << "Begin testFunc" << std::endl;
    for (int i = 0; i < n; ++i) {
        std::cout << "TestFunc before yield " << i << std::endl;
        co_yield i;
        std::cout << "TestFunc after yield " << i << std::endl;
    }
    std::cout << "End testFunc" << std::endl;
}

int main()
{
    int inp = 10;
    std::cout << "Before testFunc" << std::endl;
    MyCoroGenerator<int> gen = testFunc(inp);
    std::cout << "After testFunc" << std::endl;
    for (int i = 0; i < inp; ++i) {
        std::cout << "Cur input: " << i << std::endl;
        std::cout << "Output value: " << gen.next() << std::endl;
        std::cout << "After input: " << i << std::endl;
    }
}

上面这段代码的执行结果是：

Before testFunc
After testFunc
Cur input: 0
Output value: Begin testFunc
TestFunc before yield 0
0
After input: 0
Cur input: 1
Output value: TestFunc after yield 0
TestFunc before yield 1
1
After input: 1
Cur input: 2
Output value: TestFunc after yield 1
TestFunc before yield 2
2
After input: 2
Cur input: 3
Output value: TestFunc after yield 2
TestFunc before yield 3
3
After input: 3
Cur input: 4
Output value: TestFunc after yield 3
TestFunc before yield 4
4
After input: 4
Cur input: 5
Output value: TestFunc after yield 4
TestFunc before yield 5
5
After input: 5

...

调用时发现，函数并没有一开始就执行，而是等到next时才开始执行。执行到co_yield就会自动暂停，下次next才会继续执行

另外，函数本身并没有返回什么，但是这里可以使用MyCoroGenerator<int>接收。函数的控制权也转移到了MyCoroGenerator<int>，需要执行时就调用next。

函数在暂停后执行，依然可以继续上次的状态，这是因为，协程在挂起期间，其上下文全部都被保留，下次执行时恢复。

协程句柄

std::coroutine_handle类模板是实现协程的最底层的工具，负责存储协程的句柄。他可以特化为std::coroutine_handle<Promise>或者std::coroutine_handle<void>。

这里面的Promise是实现协程必要的Promise类，而且其名字必须是promise_type。

协程会暂停，其上下文也会保留，std::coroutine_handle就是保存和管理协程的地方。

std::coroutine_handle中方法不多，但是每个都很重要，其中：

  • done方法，可以查询协程是否已经结束
  • resume，恢复一个协程的执行
  • destroy，销毁一个协程

std::coroutine_handle是一个很底层的东西，没有RAII包裹，就像一个裸指针那样，需要手动创建、手动销毁。

所以需要一个包裹类，负责处理协程句柄的初始化和销毁，也就是Generator

Generator

C++的协程要求Generator必须有promise_type这个类，名字也必须这个，不能是其他的名字，直接定义在Generator中最方便。

template <typename T>
struct MyCoroGenerator {
    struct promise_type {
        // todo
    };
};

promise_type中有一些固定接口，这些接口如果不实现，那么协程是不完整的。

  • initial_suspend，协程是否在初始化结束后挂起，返回std::suspend_always、std::suspend_never，这是标准库里面已经定义好的类型，前者表示总是挂起，后者表示从不挂起
  • final_suspend，协程最后一次执行是否挂起，返回值和上面函数相同。由于final_suspend是收尾阶段的工作，所以必须是noexcept
  • unhandled_exception，处理协程中未被处理的异常
  • get_return_object，返回一个Generator对象
  • yield_value，处理协程返回值，就是co_yield传递过来的值
  • return_void，处理协程结束后的返回值，和return_value同时只能存在一个，如果没有返回值就用return_void
  • return_value，处理协程结束后返回值，和return_void同时只能存在一个，如果有返回值就用return_value

解释一下yield_value函数，co_yield实际是一个语法糖，相当于co_wait promise.yield_value(i)，只有实现了该函数，Genreator才能接收co_yield的返回值

函数的返回值，需要回答协程要不要挂起，也就是std::suspend_always或者std::suspend_never，因为需要yield后挂起，所以返回std::suspend_always。

为了接收返回值，需要用转发和std::optional，接收并存储返回值。

get_return_object负责创建一个Generator，一般来说，使用std::coroutine_handle<promise_type>::from_promise接口从一个Promise创建句柄，然后使用这个句柄创建Generator。

为了配合创建函数，MyGenerator需要实现一个接收句柄的构造函数。也就是MyCoroGenerator(std::coroutine_handle<promise_type> h)

#include <coroutine>
#include <iostream>
#include <optional>

template <typename T>
struct MyCoroGenerator {
    /**
     * @brief C++协程要求Generator必须有promise_type这个类型，名字也必须是promise_type
     * 最方便的方法就是定义在Generator类内部
     *
     */
    struct promise_type {
        /**
         * @brief 存放协程返回值
         * 由Generator从获取并返回
         */
        std::optional<T> opt;

        /**
         * @brief 协程是否创建时就被挂起，函数名字也必须是initial_suspend
         * std::suspend_always、std::suspend_never是标准库里面已经定义好的类型，前者表示总是挂起，后者表示从不挂起
         *
         * @return std::suspend_always 协程创建即挂起
         */
        std::suspend_always initial_suspend() const
        {
            return {};
        }

        /**
         * @brief 协程最后一次执行是否挂起，函数名字也必须是final_suspend
         * 由于final_suspend是收尾阶段的工作，所以必须是noexcept
         *
         * @return std::suspend_always 协程最后一次执行也被挂起
         */
        std::suspend_always final_suspend() const noexcept
        {
            return {};
        }

        /**
         * @brief 处理协程中未捕获异常，函数名字必须是unhandled_exception
         *
         */
        void unhandled_exception()
        {
            std::exit(EXIT_FAILURE);
        }

        /**
         * @brief 获取一个Generator对象，该对象从promise_type构造
         *
         * @return MyCoroGenerator
         */
        MyCoroGenerator get_return_object()
        {
            return MyCoroGenerator { std::coroutine_handle<promise_type>::from_promise(*this) };
        }

        /**
         * @brief 定制yield_value接口，接收co_yield返回的值
         *
         * @tparam Arg 值的类型
         * @param arg co_yield返回值
         * @return std::suspend_always 执行完后继续挂起
         */
        template <typename Arg>
        std::suspend_always yield_value(Arg&& arg)
        {
            opt.emplace(std::forward<Arg>(arg));
            return {};
        }

        /**
         * @brief 当协程结束co_return且没有返回值时，调用该函数
         * 还有一个return_value(expr)函数，负责处理协程结束且有返回值的情况
         */
        void return_void()
        {
        }
    };

    /**
     * @brief 协程句柄，存储了协程上下文，一个非常底层的东西，没有RAII
     * 用MyCoroGenerator包裹
     */
    std::coroutine_handle<promise_type> handle;

    /**
     * @brief 默认构造函数
     *
     */
    MyCoroGenerator() = default;

    /**
     * @brief 通过一个handle构造一个Generator
     *
     * @param h 从promise_type构造出来的协程句柄
     */
    MyCoroGenerator(std::coroutine_handle<promise_type> h)
        : handle(h)
    {
    }

    /**
     * @brief 移动构造函数
     *
     * @param other 其他Generator对象
     */
    MyCoroGenerator(MyCoroGenerator&& other)
    {
        if (handle) {
            handle.destroy();
        }
        handle = other.handle;
        other.handle = nullptr;
    }

    /**
     * @brief 析构函数
     *
     */
    ~MyCoroGenerator()
    {
        if (handle) {
            handle.destroy();
        }
    }

    /**
     * @brief 移动赋值函数
     *
     * @param other 其他Generator对象
     * @return MyCoroGenerator& 当前镀锡
     */
    MyCoroGenerator& operator=(MyCoroGenerator&& other)
    {
        if (handle) {
            handle.destroy();
        }
        handle = other.handle;
        other.handle = nullptr;
        return *this;
    }

    /**
     * @brief 继续执行协程，并返回执行结果
     *
     * @return T& 返回的值
     */
    T& next()
    {
        handle.resume();
        if (handle.done()) {
            // throw geneator_done("Generator done");
            throw "Generator Error";
        }
        return *(handle.promise().opt);
    }

private:
    MyCoroGenerator(const MyCoroGenerator&) = delete;
    MyCoroGenerator& operator=(const MyCoroGenerator&) = delete;
};

源码

#include <coroutine>
#include <iostream>
#include <optional>

template <typename T>
struct MyCoroGenerator {
    /**
     * @brief C++协程要求Generator必须有promise_type这个类型，名字也必须是promise_type
     * 最方便的方法就是定义在Generator类内部
     *
     */
    struct promise_type {
        /**
         * @brief 存放协程返回值
         * 由Generator从获取并返回
         */
        std::optional<T> opt;

        /**
         * @brief 协程是否创建时就被挂起，函数名字也必须是initial_suspend
         * std::suspend_always、std::suspend_never是标准库里面已经定义好的类型，前者表示总是挂起，后者表示从不挂起
         *
         * @return std::suspend_always 协程创建即挂起
         */
        std::suspend_always initial_suspend() const
        {
            return {};
        }

        /**
         * @brief 协程最后一次执行是否挂起，函数名字也必须是final_suspend
         * 由于final_suspend是收尾阶段的工作，所以必须是noexcept
         *
         * @return std::suspend_always 协程最后一次执行也被挂起
         */
        std::suspend_always final_suspend() const noexcept
        {
            return {};
        }

        /**
         * @brief 处理协程中未捕获异常，函数名字必须是unhandled_exception
         *
         */
        void unhandled_exception()
        {
            std::exit(EXIT_FAILURE);
        }

        /**
         * @brief 获取一个Generator对象，该对象从promise_type构造
         *
         * @return MyCoroGenerator
         */
        MyCoroGenerator get_return_object()
        {
            return MyCoroGenerator { std::coroutine_handle<promise_type>::from_promise(*this) };
        }

        /**
         * @brief 定制yield_value接口，接收co_yield返回的值
         *
         * @tparam Arg 值的类型
         * @param arg co_yield返回值
         * @return std::suspend_always 执行完后继续挂起
         */
        template <typename Arg>
        std::suspend_always yield_value(Arg&& arg)
        {
            opt.emplace(std::forward<Arg>(arg));
            return {};
        }

        /**
         * @brief 当协程结束co_return且没有返回值时，调用该函数
         * 还有一个return_value(expr)函数，负责处理协程结束且有返回值的情况
         */
        void return_void()
        {
        }
    };

    /**
     * @brief 协程句柄，存储了协程上下文，一个非常底层的东西，没有RAII
     * 用MyCoroGenerator包裹
     */
    std::coroutine_handle<promise_type> handle;

    /**
     * @brief 默认构造函数
     *
     */
    MyCoroGenerator() = default;

    /**
     * @brief 通过一个handle构造一个Generator
     *
     * @param h 从promise_type构造出来的协程句柄
     */
    MyCoroGenerator(std::coroutine_handle<promise_type> h)
        : handle(h)
    {
    }

    /**
     * @brief 移动构造函数
     *
     * @param other 其他Generator对象
     */
    MyCoroGenerator(MyCoroGenerator&& other)
    {
        if (handle) {
            handle.destroy();
        }
        handle = other.handle;
        other.handle = nullptr;
    }

    /**
     * @brief 析构函数
     *
     */
    ~MyCoroGenerator()
    {
        if (handle) {
            handle.destroy();
        }
    }

    /**
     * @brief 移动赋值函数
     *
     * @param other 其他Generator对象
     * @return MyCoroGenerator& 当前镀锡
     */
    MyCoroGenerator& operator=(MyCoroGenerator&& other)
    {
        if (handle) {
            handle.destroy();
        }
        handle = other.handle;
        other.handle = nullptr;
        return *this;
    }

    /**
     * @brief 继续执行协程，并返回执行结果
     *
     * @return T& 返回的值
     */
    T& next()
    {
        handle.resume();
        if (handle.done()) {
            // throw geneator_done("Generator done");
            throw "Generator Error";
        }
        return *(handle.promise().opt);
    }

private:
    MyCoroGenerator(const MyCoroGenerator&) = delete;
    MyCoroGenerator& operator=(const MyCoroGenerator&) = delete;
};

MyCoroGenerator<int> testFunc(int n)
{
    std::cout << "Begin testFunc" << std::endl;
    for (int i = 0; i < n; ++i) {
        std::cout << "TestFunc before yield " << i << std::endl;
        co_yield i;
        std::cout << "TestFunc after yield " << i << std::endl;
    }
    std::cout << "End testFunc" << std::endl;
}

int main()
{
    int inp = 10;
    std::cout << "Before testFunc" << std::endl;
    MyCoroGenerator<int> gen = testFunc(inp);
    std::cout << "After testFunc" << std::endl;
    for (int i = 0; i < inp; ++i) {
        std::cout << "Cur input: " << i << std::endl;
        std::cout << "Output value: " << gen.next() << std::endl;
        std::cout << "After input: " << i << std::endl;
    }
}

参考：C++ coroutine generator 实现笔记

izwmain
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++20 协程(一)
qq936836的专栏
03-10 2801
协程是C++20最重要的特性，C++的异步编程模式有了协程将会变得简单。协程是能暂停执行以在之后恢复的函数。C++20协程是无栈的在堆上分配一个协程帧，把函数的参数拷贝到协程帧里，会在协程帧里创建promise对象。它们通过返回到调用方暂停执行，并且从栈分离存储恢复执行需要的数据。这样就可以编写异步执行的顺序代码（例如不使用显式的回调来处理非阻塞 I/O），还支持对惰性计算的无限序列上的算法及其他用途。 协程与函数 协程是一个有点特殊的函数，相比普通函数协程的特殊之处在于它可以暂停和恢复，如下图所示：
C++ 20 协程 Coroutine
m0_73257876的博客
09-07 3069
C++ 20 的协程是一个用于异步模型，主要用于服务开发的东东，由于概念和传统的同步变成有区别，同时自身的概念，接口，关键字很多。理解起来有点难度。C++ 20的协程是一个特殊的可以挂起，恢复（重入）的函数。协程内部可以出现三个关键字。co_await awaiter用于和等待体交互，可以挂起和恢复。co_yield 用于挂起协程，co_return用于返回。编译器通过返回值（类型result）里面result::promise（承诺对象）来识别什么函数是协程函数。
C++20尝鲜-协程(二)
Respiration
12-07 1161
C++20尝鲜-协程(二)
c++ 20 协程例子
gumingyaotangwei 的专栏
04-11 512
private:public:times++;});public:return tk;return {};private:public:private:R buf_;public:});return aw;for (;;) {for (;;) {
C++20尝鲜-协程(一)
Respiration
11-27 1421
C++20尝鲜-协程(一) 什么是协程 参考[cppreference](https://zh.cppreference.com/)的解释如下： A coroutine is a function that can suspend execution to be resumed later. Coroutines are stackless: they suspend execution by returning to the caller and the data that is required to
c++20 协程(coroutine)
小x的博客
06-07 1660
c++20 协程(coroutine)
C++20 协程coroutine
华秋实的专栏
08-04 2089
#1.协程概念 协程函数与普通函数的区别： （1）普通函数执行完返回，则结束。 协程函数可以运行到一半，返回并保留上下文；下次唤醒时恢复上下文，可以接着执行。 协程与多线程： （1）协程适合IO密集型程序，一个线程可以调度执行成千上万的协程，IO事件不会阻塞线程 （2）多线程适合CPU密集型场景，每个线程都负责cpu计算，cpu得到充分利用 协程与异步： （1）都是不阻塞线程的编程方式，但是协程是用同步的方式编程、实现异步的目的，比较适合代码编写、阅读和理解 （2）异步编程通常使用callback
c++20 协程本质
c553110519的专栏
03-07 1250
c++ 20 协程本质
c++20的编程示例和深入解析
12-18
在这个深入解析中，我们将探讨C++20的一些关键特性，并通过实际编程示例进行理解。 1. **模块化（Modules）**： C++20引入了模块化，它允许程序员将代码组织成独立的单元，称为模块。这有助于减少编译时间和避免...
cpp-coroutine:用于使用Boost协程的库
05-28
在C++编程中，协程（Coroutines）是一种高级程序构造，它们允许程序员定义和控制执行流程的暂停和恢复。协程与线程和函数不同，它们不是并发执行的实体，而是提供了一种顺序控制流的方式，可以在执行过程中挂起，并...
基于ucontext实现的C++协程库.zip
04-30
本项目“基于ucontext实现的C++协程库”是针对C++编程语言设计的，其主要目标是利用ucontext库来实现轻量级的协程机制。 ucontext是Unix-like系统中的一个API，用于保存和恢复进程上下文，这使得程序可以在不同的...
Coroutine:使用线程在 C++11 中实现简单的“协程”
07-10
在C++编程中，协程是一种轻量级的并发机制，它允许程序在执行过程中挂起和恢复。...随着C++标准的演进，C++17引入了`std::coroutine`概念，C++20正式提供了原生的协程支持，使得在C++中编写高效并发代码变得更加便捷。
Python协程 yield与协程greenlet简单用法示例
01-02
本文实例讲述了Python协程 yield与协程greenlet简单用法。分享给大家供大家参考，具体如下： 协程 协程，又称微线程，纤程。英文名Coroutine。 协程是啥 协程是python个中另外一种实现多任务的方式，只不过比线程更...
关于C++工厂模式下可见性修饰符的杂谈
qq_41907714的博客
01-12 301
c++继承、工厂，可见性修饰符 以下demo示例不是很典型，但是使用工厂的一个例子，其中有一个问题，就是对于处于继承体系上的基类和派生类（实现）而言，在工厂模式中，究竟是开放基类的析构函数还是开放派生类的析构函数？ /** * @brief C++类内protected、private构造、析构的艺术 * @note 背景知识： * 1. 如果不想让基类被实例化的方式有：①让基类带有纯虚成员函数（成为接口）；②限定基类的构造函数为非public * 不讨论接口情况，若基类构造函数被声明为
C++20 协程实现线程同步示例
qq_42896106的博客
10-02 533
【代码】C++20 协程 线程同步示例。
c++20协程实践 + 异步IO + 多线程
weixin_47488337的博客
09-25 387
通过上面的描述，我们知道，这里涉及到几个队列，协程任务完成队列(待恢复队列)和任务队列（后台执行任务），有了这些，再加上在特定的位置暂停协程，我们就能自己完成对协程的执行流做封装，并且将一些网络库、IO操作变成协程调用。减少线程同步以及回调等逻辑，让程序线性执行。
C++ 注释风格
AI.PLAY
03-31 1015
注释风格 注释风格可以根据自己的个人习惯来定，但关键是要统一，为了制定出统一的注释风格所以采用Doxygen注释风格。 使用Doxygen软件可以很方便的生成函数描述文档。 DoxyGen常用命令 命令 生成字段名 说明 @file 文件名 @autho...
C++复习笔记--C++常用注释规范
牵一只蜗牛去散步
09-15 1359
⑨ @retval 表示返回值，用于说明返回值的意义（例如可以说明 -1 表示异常）① @brief 表示简介，用于简单介绍函数或类的作用和功能；② @param 表示参数，用于介绍和说明函数或类的参数；③ @return 表示返回类型，用于说明函数的返回类型；⑦ @exception 用于说明可能引起的异常信息；⑧ @property 表示属性，用于说明属性信息；⑥ @version 表示版本，用于介绍版本信息；④ @author 表示作者，用于介绍作者信息；⑤ @data 表示日期，用于介绍日期信息；
C++20中的constinit说明符
最新发布
网络资源是无限的
07-14 846
C++20中的constinit说明符
C++ 20 协程示例
04-01
很抱歉，我无法提供代码示例，因为作为AI语言模型，我无法编写代码。但我可以为您解释一下协程的概念和用法。 协程（Coroutine）是一种用户级的轻量级线程，也称为协作式多任务。它不同于操作系统内核级的线程，协程不会被操作系统内核调度，而是由用户代码控制。在协程中，一个线程可以有多个执行流，这些执行流在适当的时候可以相互切换，从而实现多任务并发。 协程是一种非常有用的编程技术，用于编写高效、可读性强、可维护的代码。协程通常用于异步编程，因为它可以在不阻塞主线程的情况下执行耗时的操作。 以下是一个可能的协程示例： ```python import asyncio async def coroutine_1(): print('Coroutine 1 started') await asyncio.sleep(1) print('Coroutine 1 finished') async def coroutine_2(): print('Coroutine 2 started') await asyncio.sleep(2) print('Coroutine 2 finished') async def main(): task1 = asyncio.create_task(coroutine_1()) task2 = asyncio.create_task(coroutine_2()) print('Main started') await asyncio.gather(task1, task2) print('Main finished') asyncio.run(main()) ``` 在上面的示例中，我们定义了两个协程函数 coroutine_1 和 coroutine_2，这些函数用于执行一些异步任务。然后我们定义了一个主函数 main，它创建了两个任务 task1 和 task2，这些任务会在协程函数中执行。最后，我们使用 asyncio.run() 函数来运行主函数，从而启动协程并等待它们完成。 在上面的示例中，我们使用了 asyncio 库来实现协程。asyncio 是 Python 3 中的一个标准库，它提供了一些工具和函数来编写协程代码。asyncio 库的主要组件是事件循环（Event Loop），它负责调度协程的执行。我们使用 asyncio.run() 函数来创建一个新的事件循环并运行协程。然后我们使用 asyncio.create_task() 函数来创建任务，这些任务会在协程函数中执行。最后，我们使用 asyncio.gather() 函数来等待所有任务完成。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值