Boost中的协程—Boost.Coroutine2

尽管可以有不同的翻译,coroutine本文被叫作协程。

概念

Coroutine是相对于routine(过程)而提出的,它与一般的父程序调用子程序的routine不同之处在于,它允许挂起一个程序执行点,过后再从挂起的地方继续运行,是一种更高级的程序运行顺序控制。为保证程序挂起再恢复,协程有其自己的栈和控制块,记录挂起时的状态。

协程有如下特点:

  1. 同其他数据类型一样,协程也是第一类(first-class)对象,可以被当参数传递等操作;
  2. 运行特点是挂起运行,离开协程,过后再进入,恢复运行;
  3. 具有对称和非对称的转移控制机制
  4. 挂起前和恢复后本地变量的值是一致的;
  5. 有stackless和stackful两种类型

对称转移是指所有协程都是对等的,协程控制权跳转时,必须显式指明将控制权转给谁。非对称转移是指协程记录调用者,因此可以隐式转移控制权(给调用者)。

stackful协程能从嵌套的栈结构中恢复,而stackless协程,因为没有保存栈,因而只能在最上层(top-level)的过程中使用,被最上层过程调用的过程就不能再挂起了,也就是不能有两个协程同时被挂起。

为实现协程,一些语言特别引入了关键字,在语言层面支持协程,但目前C++不是如此,例如下文的Boost.Asio中,虽然定义了yield,但其实是一个宏。

协程与回调函数

采用协程与采用回调通常被用来对比。而它们通常与事件驱动式编程有关。

事件驱动式编程方式如下图:

有若干断续发生的事件源(source),若干个处理程序(handler),中间有一个分发/调度器(dispatcher),当有事件发生时,将其发给某个合适的处理程序进行处理。这里的事件一般是程序外部事件(如I/O),有特定的硬件进行侦测,因此不消耗CPU资源,也就是程序不用管,如果程序等在那,就是同步处理,如果做些别的事情,就是异步处理。

基于事件驱动的异步编程可以大大提高程序的处理效率,达到了“并行”的效果。基于事件驱动的异步编程可以采用多线程方式,也可以采用单线程+回调方式。后者的效率更高些,但会使代码执行碎片化—将一个连续过程切成若干hanlder,执行过程在handler函数间跳来跳去,同时,一些本应统一的处理,如错误、状态,就不得不深入每个handler,使得编程繁复,不直观。

Boost.Corountine2

Corountine2是相对于Corountine而言的,在Boost v1.59被引入,Boost.Corountine目前已被标记为deprecated,因此不再提及。

Boost.Corountine2使用了Boost.Context,因此要使用Boost.Corountine2,必须先编译Boost.Context。

Boost.Corountine2几个特征:

  1. 非对称转移控制(放弃了对称转移)
  2. stackful
  3. 对象只能移动(moveable),不能拷贝(copyable),因为协程对象控制的有些资源,如栈,只能独享
  4. coroutine<>::push_type 和coroutine<>::pull_type保存栈使用的是块式内存,可动态扩展,因此不用关心初始栈的大小,在析构时,所有的内存都被释放。
  5. 上下文切换通过coroutine<>::push_type::operator() ,coroutine<>::pull_type::operator()来完成,因此这两个函数内部不能再调用自身。

有两个创建协程的类:coroutine<>::pull_type和coroutine<>::push_type,pull的意思是从主运行环境可以“拉”数据到协程环境,push的意思是从协程环境将数据“推”到主运行环境中,coroutine<>::pull_type拉数据的方法是get(),coroutine<>::push_type推数据的方法是operator(),即在协程中,pull_type.get()可以得到外部传入的数据,而push_type()可以将数据传递到外部环境。为此,coroutine<>::pull_type提供了输入iterator及重载了std::begin()/std::end(),coroutine<>::push_type提供了输出iterator及重载了std::begin()/std::end(),方便它们的循环调用。

示例1如下。

int main()
{
    typedef boost::coroutines2::coroutine<int>   coro_t2;
    std::cout<< "start corountine" << std::endl;	
    coro_t2::pull_type source( // constructor enters coroutine-function
         [&](coro_t2::push_type& sink){
            std::cout<< " sink1" << std::endl;	
            sink(1); // push {1} back to main-context
            std::cout<< " sink2" << std::endl;
            sink(2); // push {2} back to main-context
            std::cout<< " sink3" << std::endl;
            sink(3); // push {3} back to main-context
        });
    std::cout<< "start while" << std::endl;	
    while(source)    // test if pull-coroutine is valid
    {
        int ret=source.get(); // pushed data,that is the argument of sink()
        std::cout<< "move to coroutine-function "<< ret << std::endl;
        source();             // context-switch to coroutine-function
        std::cout<< "back from coroutine-function "<< std::endl;
}
return 0;
}

输出为:
start corountine
 sink1
start while
move to coroutine-function 1
 sink2
back from coroutine-function
move to coroutine-function 2
 sink3
back from coroutine-function
move to coroutine-function 3
back from coroutine-function

该示例以coroutine<>::pull_type创建协程,以coroutine<>::push_type作为协程函数的参数,由于主环境中是pull,因此主环境中可以得到协程传出的数据,而主程序的数据只能通过全局变量来传递。程序跳转的变化通过输出可以清晰看出来:协程函数中的push函数(即sink)就是跳转点,下次再次进入协程函数时接着运行,主程序的跳转点就是pull函数(即source)。

示例2如下。

int main()
{
    typedef boost::coroutines2::coroutine<int>   coro_t3;
    std::cout<< "start corountine" << std::endl;	
    coro_t3::push_type sink( 
         [&](coro_t3::pull_type& source){
            int num;
            num=source.get();
            std::cout<< " source1: "<<num << std::endl;	
            source();   //back to main-context
            std::cout<< " source2: "<<num << "   "<<source.get()<< std::endl;
            source();
            std::cout<< " source3: "<<num << "   "<<source.get()<< std::endl;
            source();
        });
    std::cout<< "start while" << std::endl;	
    int i=1;
    while(sink)    // test if pull-coroutine is valid
    {
        std::cout<< "move to coroutine-function "<<i << std::endl;
        sink(i);             // context-switch to coroutine-function
        std::cout<< "back from coroutine-function "<<i << std::endl;
        i++;
}
return 0;
}

输出为:
start corountine
start while
move to coroutine-function 1
 source1: 1
back from coroutine-function 1
move to coroutine-function 2
 source2: 1   2
back from coroutine-function 2
move to coroutine-function 3
 source3: 1   3
back from coroutine-function 3
move to coroutine-function 4
back from coroutine-function 4

该示例以coroutine<>::push_type创建协程,以coroutine<>::pull_type作为协程函数的参数,由于主环境中是push,因此主环境中可以将数据传递到协程,而协程数据只能通过全局变量来传递。注意到协程中的变量num的状态在运行中是得到保存的。程序的跳转通过输出也可以清晰看出,source/sink就是跳转点。该示例与示例1其实非常类似,说明coroutine<>::push_type和coroutine<>::pull_type其实是对等的,应用时注意两个区别:

  1. 数据传输方式不同,coroutine<>::pull_type用get(),而coroutine<>::push_type直接用参数。
  2. coroutine<>::pull_type在构造函数时,调用了一次协程函数(注意示例1的输出),而coroutine<>::push_type没有。

总结

协程的出现,改变了函数只有唯一运行入口的观点,一个较长的过程,尤其是过程中存在需要等待的步骤,也可以用一个函数来编写,等待的时候“跑”到函数外干点别的,然后再回来接着原来的步骤继续运行,如果采用回调的方式,需将这个过程切成一块一块的,块与块之间可以做点别的事情。

协程的出现使我们的编程方式多了一种选择,但协程的编程,尤其是与一些I/O异步操作结合起来用时,难度还是比较大的,因此我们通常并不直接使用coroutine库,Boost.Asio已经为我们封装了协程的功能,直接用Boost.Asio就好了。

  • 4
    点赞
  • 19
    收藏
  • 打赏
    打赏
  • 2
    评论

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论 2

打赏作者

guxch

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值