C++20尝鲜-协程(一)

最新推荐文章于 2024-01-31 20:54:24 发布
最新推荐文章于 2024-01-31 20:54:24 发布
阅读量1.4k 收藏 5
点赞数 1
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37357702/article/details/121585623
版权

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 resume execution is stored separately from the stack. This allows for sequential code that executes asynchronously

从上面的解释可以简单解释下C++20中协程的基本概念

  1. 协程就是一种特殊的函数，它可以在函数执行到某个地方的时候暂停执行，返回给调用者（可以有一个返回值），并允许随后从暂停的地方恢复继续执行。
  2. 协程分为有栈协程和无栈协程，C++20的协程是无栈协程。
  3. 协程可以帮助我们以同步的方式实现异步的逻辑

C++20协程示例

#include <coroutine>
#include <iostream>

struct HelloCoroutine {
    struct HelloPromise {
        HelloCoroutine get_return_object() {
            std::cout << "==============call get_return_object==============" << std::endl;
            return std::coroutine_handle<HelloPromise>::from_promise(*this);
        }
        std::suspend_never initial_suspend() {
            std::cout << "==============call initial_suspend==============" << std::endl;
            return {}; 
        }

        std::suspend_always final_suspend() noexcept {
            std::cout << "==============call final_suspend==============" << std::endl;
            return {}; 
        }
        void unhandled_exception() {}
    };

    using promise_type = HelloPromise;
    HelloCoroutine(std::coroutine_handle<HelloPromise> h) : handle(h) {}

    std::coroutine_handle<HelloPromise> handle;
};

std::coroutine_handle<> coroutine_handle;
struct AWaitableObject
{
    AWaitableObject() {}

    bool await_ready() const { 
        std::cout << "==============call await_ready==============" << std::endl;
        return false; 
    }

    int await_resume() { 
        std::cout << "==============call await_resume==============" << std::endl;
        return 0; 
    }

    void await_suspend(std::coroutine_handle<> handle) {
        std::cout << "==============call await_suspend==============" << std::endl;
        coroutine_handle = handle;
    }

};

HelloCoroutine hello() {
    std::cout << "Hello " << std::endl;
    co_await AWaitableObject{};
    std::cout << "world!" << std::endl;
}

int main() {
    std::cout << "start" << std::endl;

    HelloCoroutine coro = hello();

    std::cout << "calling resume" << std::endl;
    coro.handle.resume();

    std::cout << "destroy" << std::endl;
    coro.handle.destroy();

    return 0;
}

用gcc-11.1.0版本编译并运行

root@DESKTOP-QA1H9TD:/mnt/d/Code/os# g++-11 coroutine.cpp -std=c++2a
root@DESKTOP-QA1H9TD:/mnt/d/Code/os# ./a.out
start
==============call get_return_object==============
==============call initial_suspend==============
Hello
==============call await_ready==============
==============call await_suspend==============
calling resume
==============call await_resume==============
world!
==============call final_suspend==============
destroy
root@DESKTOP-QA1H9TD:/mnt/d/Code/os#

观察运行结果发现，在使用了关键字co_await后会返回到caller, 在main中使用resume()后，回到co_await的赋值等式中运行

C++20协程的细节

Results CoroutineFunction(){
	
	co_await AwaitatbleObject();
	
	co_return {};
}

一个协程函数的形式如上所示，当函数体内出现了co_await, co_yield，co_return这三个关键字之后，就会被当成一个协程函数。并且，编译器要求返回值类型包含一个promise_type的结构以及需要实现必要的函数，以上一个例子中的HelloCoroutine类型为例:

struct HelloCoroutine {
    struct HelloPromise {
        HelloCoroutine get_return_object() {
            std::cout << "==============call get_return_object==============" << std::endl;
            return std::coroutine_handle<HelloPromise>::from_promise(*this);
        }
        std::suspend_never initial_suspend() {
            std::cout << "==============call initial_suspend==============" << std::endl;
            return {}; 
        }

        std::suspend_always final_suspend() noexcept {
            std::cout << "==============call final_suspend==============" << std::endl;
            return {}; 
        }
        void unhandled_exception() {}
    };

promise_type放在协程函数返回值类型HelloCoroutine中，用于控制协程的流程。观察打印结果并总结，它在运行过程中主要分为如下三个阶段：

  1. 初始化准备阶段

    • 协程函数运行后，首先生成一个promise_type对象
    • 调用get_return_object()函数创建返回值对象，在协程第一次返回时就会把这个对象返回给caller;
    • 调用initial_suspend()函数，这个返回值有两个选择suspend_never/suspend_always，never表示继续运行，always表示协程挂起，同时把返回值对象返回，所以这个接口的语义是，协程创建后是否马上运行

  2. 运行阶段

    • 开始运行协程函数，如果出现异常会调用unhandled_exception()去处理

    • 例子中用到了co_await关键字，这是一个一元操作符，操作的对象为awaitable类型，就是实现await_ready(), await_resume(), await_suspend( ) 的类型，负责管理协程挂起时的行为，如例子所示的AWaitableObject。

      struct AWaitableObject
{
    AWaitableObject() {}

    bool await_ready() const { 
        std::cout << "==============call await_ready==============" << std::endl;
        return false; 
    }

    int await_resume() { 
        std::cout << "==============call await_resume==============" << std::endl;
        return 0; 
    }

    void await_suspend(std::coroutine_handle<> handle) {
        std::cout << "==============call await_suspend==============" << std::endl;
        coroutine_handle = handle;
    }

};

      首先运行await_ready( )函数，判断是否要挂起当前线程: 如果是false，则挂起； 如果是true，则表示不要挂起，然后会调用await_suspend()，用于提供挂起前的处理，然后协程就被挂在这个点

      然后一旦协程被恢复运行时，继续调用**await_resume()**在返回一个值到协程挂起点

      co_await除了显示使用之外，promise_type的接口中凡是返回了suspend_never/suspend_always的地方，编译器都是通过co_await的方式调用这些函数的，suspend_never/suspend_always是awaitable类型

      struct suspend_always
  {
    bool await_ready() { return false; }

    void await_suspend(coroutine_handle<>) {}

    void await_resume() {}
  };

  struct suspend_never
  {
    bool await_ready() { return true; }

    void await_suspend(coroutine_handle<>) {}

    void await_resume() {}
  };

    • 如果遇到co_yield var这样的表达式，表示想要挂起当前协程，返回一个值给caller, 编译器相当于调用了yield_value(var)方法，我们可以此时将值设置到Result的相关变量中，编译器会继续根据函数的返回值判断是否为suspend_always判断要返回到caller点。改造原示例如下：

      struct HelloCoroutine {
    struct HelloPromise {
        std::string_view value_;

        HelloCoroutine get_return_object() {
            return std::coroutine_handle<HelloPromise>::from_promise(*this);
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() {}

        std::suspend_always yield_value(std::string_view value) {
            value_ = value;
            std::cout << value_ << std::endl;
            return {};
        }
    };

    using promise_type = HelloPromise;
    HelloCoroutine(std::coroutine_handle<HelloPromise> h) : handle(h) {}

    std::coroutine_handle<HelloPromise> handle;
};

HelloCoroutine hello() {
    std::string_view s = "Hello ";
    co_yield s;

    std::cout << "world" << std::endl;
}

    • 如果co_return这样的表达式，想要结束协程返回一个对象，则会调用return_value()这个函数，设置好要返回的相关值； 如果整个协程都没有出现co_return，则会调用return_void()

      struct HelloCoroutine {
    struct HelloPromise {
        HelloCoroutine get_return_object() {
            return std::coroutine_handle<HelloPromise>::from_promise(*this);
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() { return {}; }
        void unhandled_exception() {}

        void return_value(int value) { 
            std::cout << "got co_return value " << value << std::endl; 
        }
    };

    using promise_type = HelloPromise;
    HelloCoroutine(std::coroutine_handle<HelloPromise> h) : handle(h) {}

    std::coroutine_handle<HelloPromise> handle;
};

HelloCoroutine hello() {
    std::cout << "Hello " << std::endl;
    co_await std::suspend_always{};
    std::cout << "world!" << std::endl;
    co_return 42;
}

  3. 结束阶段

    • 最后调用final_suspend()判断协程已处理完毕释放前是否要挂起
ImRespiration
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++20 协程(一)
qq936836的专栏
03-10 2781
协程是C++20最重要的特性，C++的异步编程模式有了协程将会变得简单。协程是能暂停执行以在之后恢复的函数。C++20协程是无栈的在堆上分配一个协程帧，把函数的参数拷贝到协程帧里，会在协程帧里创建promise对象。它们通过返回到调用方暂停执行，并且从栈分离存储恢复执行需要的数据。这样就可以编写异步执行的顺序代码（例如不使用显式的回调来处理非阻塞 I/O），还支持对惰性计算的无限序列上的算法及其他用途。 协程与函数 协程是一个有点特殊的函数，相比普通函数协程的特殊之处在于它可以暂停和恢复，如下图所示：
c++ 20 协程例子
gumingyaotangwei 的专栏
04-11 479
private:public:times++;});public:return tk;return {};private:public:private:R buf_;public:});return aw;for (;;) {for (;;) {
C++20中的协程(Coroutine)
Ninsun的博客
09-16 1万+
目录C++20中的协程(Coroutine)那么，什么是协程？那么这么好用的协程，是不是只要C++20一推出，我们加上一个关键字就能直接把异步调用转化为同步调用呢？协程函数和Awaitable类那么，到底要如何使用协程呢？写在最后 C++20中的协程(Coroutine) 从2017年开始, 协程(Coroutine)的概念就开始被建议加入C++20的标准中了，并已经开始有人对C++20协程的提案进行了介绍。1事实上，协程的概念在很早就出现了，甚至其他语言（JS，Python，C#等）早就已经支持了协程。
python 协程 （概念+示例代码）
ChaoChao66666的博客
09-14 897
1. 迭代器 1.1 迭代器应用：自定义列表 1.2 迭代器应用：斐波那契数列 2. 生成器 2.1 生成器案例：斐波那契数列 2.2 生成器注意事项 3. 协程 3.1 yield 简单实现协程 3.2 greenlet实现协程 3.3 gevent实现协程
C/C++中的协程
07-28 671
协程是通用的controlstructures，其中流控制在两个不同的例程之间协同传递而不会返回。如果您使用过Python或C#，您可能知道有一个名为yield的关键字，它允许示例是使用yield的Python3代码。1234这段代码演示了yield的工作原理，并简要介绍了howthecontrolischangedbetweenthecallerandcallee。...
C++20协程完整实现
09-21
当然这些代码建议有一定c++基础以及协程基础的研发人员 当然这里的代码去掉了同步等待以及推出时同步各个协程退出的代码，关于这些我们可以参考cppcoro的源码 https://github.com/lewissbaker/cppcoro。 这里面详细...
一个基于 C++20 的异步协程网络库.zip
最新发布
06-03
C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。C++是C语言的扩展，旨在提供更强大的编程能力，包括面向对象编程和泛型编程的支持。C++支持数据...
C++版本Savitzky-Golay 滤波器
08-20
C++版本Savitzky-Golay 滤波器，包括序列噪声去除与插值等等。
C++ Lambda Story - From C++98 to C++20.pdf
06-05
C++ Lambda Story - From C++98 to C++20.md 1/1/2023 3 / 92 2020 年 01 ⽉ 05 ⽇ - 语法、更好的例⼦、措辞、IIFE 部分、C++20 更新。 2020 年 04 ⽉ 17 ⽇ - C++20 章节重写、语法、措辞、布局。 2020 年 04 ⽉ ...
windows下c++版faster -rcnn
11-24
windows下c++版faster -rcnn
c++ 2017 协程
08-15
这是一份最新的关于c++中协程使用的说明文档，展示了何时使用，为何使用。
C++20协程原理和应用
热门推荐
CSDN资讯
04-12 1万+
C++ 资深技术专家祁宇立足于 C++20 使用的无栈协程标准，以具体示例分享协程的具体应用实践与经验。
第 10 章：在C++中使用协程进行系统编程
cppclub的博客
01-31 770
一个进程就是一个程序的运行实例。它有自己的地址空间，除了通过共享内存，不与其他进程共享。线程存在于进程中，它们不能脱离进程存在，尽管在Linux中，进程和线程都被视为任务。它们以相同的方式被调度，并且在内核级别有相同的控制结构。尽管如此，线程被认为是轻量级的，因为程序的初始负载的较大开销由父进程承担。但这并不是完整的情况。还有纤程和协程。如果说进程和线程是真正的并发并且在共享资源上并行工作，纤程就像线程，但不符合并发。虽然线程通常依赖于任务调度器的抢占式时间分片，纤程使用协作式多任务处理。
C++20协程初探！
QcloudCommunity的博客
09-28 1179
导语|本文推选自腾讯云开发者社区-【技思广益 · 腾讯技术人原创集】专栏。该专栏是腾讯云开发者社区为腾讯技术人与广泛开发者打造的分享交流窗口。栏目邀约腾讯技术人分享原创的技术积淀，与广泛开发者互启迪共成长。本文作者是腾讯后台开发工程师杨良聪。协程(coroutine)是在执行过程中可以被挂起，在后续可以被恢复执行的函数。在C++20中，当一个函数内部出现了co_await、co_yield、c...
【并发编程二十一：终章】c++20协程( co_yield、co_return、co_await ）
junxuezheng的博客
03-05 2538
对比代码中的备注，我们知道协程开始时，在协程的状态对象分配内存后，调用promise_type的构造函数为协程的状态对象分配内存失败时构造成功后开始执行在以上函数后执行协程结束前执行出现未经处理的异常时执行co_return 时执行，return_void跟return_value二选一co_yield时执行。
C++20尝鲜-协程(二)
Respiration
12-07 1151
C++20尝鲜-协程(二)
C++协程入门
HerosOfEarth的博客
05-08 1472
#ifndef _COROUTINE_H__ #define _COROUTINE_H__ #include <memory> #include <functional> #include <ucontext.h> class Coroutine : public std::enable_shared_from_this<Coroutine> { ...
C++20 协程
gaoZhuanMing的博客
01-01 2856
1. 简介 协程就是一个可以挂起执行，稍后再恢复执行的函数。 协程是无栈式的（stackless），协程挂起时会返回到调用者，且恢复执行所需的数据会分开存储，而不放在栈上。 只要一个函数包含 co_await、co_yield 或 co_return 关键字，则它就是协程。 一个协程关联有如下多个对象： promise 对象：在协程内部操作此对象，协程通过它提交返回值或异常； 协程句柄：在协程外部操作此对象，用于恢复协程的执行或销毁协程帧； 协程状态：在堆上分配的内部状态。 2. co_await 操
用c++写一个协程的示例
02-21
// 创建一个协程 int coroutine_id = create_coroutine(); // 启动协程 resume_coroutine(coroutine_id); // 传递参数 int param = 10; pass_parameter(coroutine_id, param); // 停止协程 suspend_coroutine...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值