C++20 协程体验

1 介绍

  • 协程是比线程更加轻量级并发编程方式,CPU资源在用户态进行切换,CPU切换信息在用户态保存。

  • 协程完成异步的调用流程,并对用户展示出同步的使用方式。

  • 协程的调度由应用层决定,所以不同的实现会有不同的调度方式,调度策略比较灵活。

  • 协程是基于线程之上运行,同一个线程中,协程是串行的,不会产生线程资源的竞争,不同的协程间却是相互交叉运行的,只要依赖的线程没有终止,协程最终会跳转回来。

  • 协程可以充分利用单核CPU的资源,但是不太好利用多核CPU资源。

  • c++20 协程使用三大关键字 co_wait,co_return,co_yield

  • 在函数中使用到以上关键字的函数被称为协程函数,并且通过该关键字完成跳转。

2 使用

如果要使用协程函数,需要定义promise_type以及基本成员函数实现。

包括get_return_object、initial_suspend、final_suspend、unhandled_exception。

演示代码最下面展示

co_return 执行完协程函数并返回结果

需要额外定义return_void函数。

流程分析:

1 可以看出调用co_return跳转到return_void,return_void执行完后,main函数向下执行。

2 "co_test1 end"并没有打印,说明协程函数co_test1分割开来,通过co_return切换了CPU资源,使主线程继续执行。

co_await 执行到异步操作处,判断并进行挂起操作。

使用co_await 还需要再定义xxxx类并实现await_ready、await_suspend、await_resume函数。

1 协程函数中调用co_await后,跳转xxx的await_ready并判断是否就绪,如果是true,则协程函数调回继续运行,反之进入await_suspend挂起,协程函数跳出,直到调用await_resume后再次跳入协程函数执行余下操作。

2 可以看到在“co_test2 result”打印之前,main函数已执行完成,等到await_resume后依然会跳回协程函数并执行余下部分。

co_yield 让出操作

需要额外定义yield_value函数。

1 执行co_yield 会跳转到yield_value函数中,通过resume以及promise操作获取结果。

3 代码用例

以下代码在linux下测试,gcc版本需要 linux-gcc10.1以上。

编译指令:g++ faw.cpp -fcoroutines -std=c++20

#include <iostream>
#include <coroutine>
#include <thread>
#include <functional>
#include <chrono>

template <typename... Args>
void print_log(const char* fmt, Args... args) {
    char log_buf[128] = { 0 };
    snprintf(log_buf, 128, fmt, args...);
    char time_buf[64] = { 0 };
    unsigned long tid = pthread_self();
    char buf[160] = { 0 };
    snprintf(buf, 160, "[%lu] [%s]", tid, log_buf);
    std::cout << buf << std::endl;
}

using callback_t = std::function<void(int)>;
void async_op(int value, callback_t cb) {
      std::thread t([value, cb]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
            cb(value+1000);
      });
      t.detach();
}

struct MyTask {
      struct promise_type;
      using handle_t = std::coroutine_handle<promise_type>;  //yield操作
      MyTask() {
      }
      MyTask(handle_t handle)
            : handle_(handle) {
      }
      struct promise_type {
            MyTask get_return_object() {
                  print_log("get_return_object beg");
                  return MyTask(handle_t::from_promise(*this));
            }
            std::suspend_never initial_suspend() {
                  print_log("initial_suspend beg");
                  return std::suspend_never();
            }
            std::suspend_never final_suspend() noexcept {
                  print_log("final_suspend beg");
                  return std::suspend_never();
            }

            //co_return
            void return_void() {
                  print_log("return_void beg");
                  std::this_thread::sleep_for(std::chrono::milliseconds(1000)); //测试异步
            }
            void unhandled_exception() {}

            //co_yield
            auto yield_value(int v) {
                  data_ = v;
                  return std::suspend_always();
            }

            int data_ = 0;
      };

 int get_value() {
       handle_.resume();
       if(!handle_.done()){
            return handle_.promise().data_;
       }
       return -1;
 }

      handle_t handle_;
};

//co_await操作
class AwaitOp {
public:
      AwaitOp(int value)
            : input_(value), result_(0) {}

      bool await_ready() {
            print_log("await_ready beg");
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));  //测试阻塞情况
            return false;
      }

      void await_suspend(std::coroutine_handle<> handle) {
            auto cb = [handle, this](int value) mutable {
                  result_ = value;
                  print_log("----------");
                  handle.resume();   //执行完后调回
                  
            };
            async_op(input_, cb);
      }

      int await_resume() {
            print_log("await_resume beg");
            return result_;
      }
private:
      int input_;;
      int result_;
};

#if 1
MyTask co_test1(){
    print_log("co_test1 beg");
    co_return;   //业务跳转,协程函数退出
    print_log("co_test1 end");
}

MyTask co_test2(){
    print_log("co_test2 beg");
    int input= 999;
    int result = co_await AwaitOp(input);   //业务跳转,协程函数退出
    print_log("co_test2 result=%d",result);
    co_return;
    print_log("co_test2 end");
}

#endif
MyTask co_test3_2(){
    print_log("co_test3_2 beg");
    int t = 99;
    co_yield t;  //切换出去
    print_log("co_test3_2 end");
}

void co_test3(){
      MyTask task = co_test3_2();
      int result = task.get_value();  //切换结果
      print_log("co_test3 result=%d",result);
}

int main() {
      print_log("main beg");

      co_test1();     //co_return测试
      //co_test2();   //co_await测试
      //co_test3();   //co_yield测试
      print_log("main end");
      getchar();
      return 0;
}

  • 5
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
很抱歉,我无法提供代码示例,因为作为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() 函数来等待所有任务完成。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值