ucontext-人人都可以实现的简单协程库

Posted ty_laurel

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了ucontext-人人都可以实现的简单协程库相关的知识，希望对你有一定的参考价值。

1.协程介绍

协程是一种轻量级的、用户态的执行单元。协程拥有自己的寄存器上下文和栈，协程调度切换时，将寄存器上下文和栈保存到其他地方，再切回来的时候，恢复先前保存的寄存器上下文和栈。不管是进程还是线程，每次阻塞、切换都需要陷入系统调用，先让CPU跑操作系统的调度程序，然后再由调度程序决定该跑哪一个进程/线程。协程的休眠和唤醒都是发生在用户态，也就是说应用程序开发者要自己负责协程的休眠和唤醒，

主要有以下特点：
1.占用的资源少。
2.所有的切换和调度都发生在用户态。
3.协程不适合CPU密集型（耗时），只适合I/O密集型，无法利用多核资源，不能实现并行

首先我们可以看看有哪些语言已经具备协程语义：

  • 比较重量级的有C#、erlang、golang*
  • 轻量级有python、lua、javascript、ruby
  • 还有函数式的scala、scheme等。

c/c++不直接支持协程语义，但有不少开源的协程库，如：
Protothreads：一个“蝇量级” C 语言协程库
libco:来自腾讯的开源协程库libco介绍，利用了glibc中的ucontext相关调用保存协程上下文，官网，介绍信息
coroutine:云风的一个C语言同步协程库，详细信息
Quasar：java中的一种协程库，官网

目前看到大概有四种实现协程的方式：

  • 第一种：利用glibc 的 ucontext组件(云风的库)
  • 第二种：使用汇编代码来切换上下文(实现c协程)
  • 第三种：利用C语言语法switch-case的奇淫技巧来实现（Protothreads)
  • 第四种：利用了 C 语言的 setjmp 和 longjmp（ 一种协程的 C/C++ 实现),要求函数里面使用 static local 的变量来保存协程内部的数据）

本篇主要使用ucontext来实现简单的协程库。

2.ucontext初接触

利用ucontext提供的四个函数getcontext(),setcontext(),makecontext(),swapcontext()可以在一个进程中实现用户级的线程切换。

本节我们先来看ucontext实现的一个简单的例子：

[cpp]  view plain  copy
  1. #include <stdio.h>  
  2. #include <ucontext.h>  
  3. #include <unistd.h>  
  4.   
  5. int main(int argc, const char *argv[])  
  6.     ucontext_t context;  
  7.   
  8.     getcontext(&context);  
  9.     puts("Hello world");  
  10.     sleep(1);  
  11.     setcontext(&context);  
  12.     return 0;  
  13.   

注：示例代码来自维基百科.

保存上述代码到example.c,执行编译命令：

gcc example.c -o example

想想程序运行的结果会是什么样？

[plain]  view plain  copy
  1. cxy@ubuntu:~$ ./example   
  2. Hello world  
  3. Hello world  
  4. Hello world  
  5. Hello world  
  6. Hello world  
  7. Hello world  
  8. Hello world  
  9. ^C  
  10. cxy@ubuntu:~$  

上面是程序执行的部分输出，不知道是否和你想得一样呢？我们可以看到，程序在输出第一个“Hello world"后并没有退出程序，而是持续不断的输出”Hello world“。其实是程序通过getcontext先保存了一个上下文,然后输出"Hello world",在通过setcontext恢复到getcontext的地方，重新执行代码，所以导致程序不断的输出”Hello world“，在我这个菜鸟的眼里，这简直就是一个神奇的跳转。

那么问题来了，ucontext到底是什么？

3.ucontext组件到底是什么

在类System V环境中,在头文件< ucontext.h > 中定义了两个结构类型，mcontext_t和ucontext_t和四个函数getcontext(),setcontext(),makecontext(),swapcontext().利用它们可以在一个进程中实现用户级的线程切换。

mcontext_t类型与机器相关，并且不透明.ucontext_t结构体则至少拥有以下几个域:

[cpp]  view plain  copy
  1. typedef struct ucontext   
  2.     struct ucontext *uc_link;  
  3.     sigset_t         uc_sigmask;  
  4.     stack_t          uc_stack;  
  5.     mcontext_t       uc_mcontext;  
  6.     ...  
  7.  ucontext_t;  

当当前上下文(如使用makecontext创建的上下文）运行终止时系统会恢复uc_link指向的上下文；uc_sigmask为该上下文中的阻塞信号集合；uc_stack为该上下文中使用的栈；uc_mcontext保存的上下文的特定机器表示，包括调用线程的特定寄存器等。

下面详细介绍四个函数：

int getcontext(ucontext_t *ucp);

初始化ucp结构体，将当前的上下文保存到ucp中

int setcontext(const ucontext_t *ucp);

设置当前的上下文为ucp，setcontext的上下文ucp应该通过getcontext或者makecontext取得，如果调用成功则不返回。如果上下文是通过调用getcontext()取得,程序会继续执行这个调用。如果上下文是通过调用makecontext取得,程序会调用makecontext函数的第二个参数指向的函数，如果func函数返回,则恢复makecontext第一个参数指向的上下文第一个参数指向的上下文context_t中指向的uc_link.如果uc_link为NULL,则线程退出。

void makecontext(ucontext_t *ucp, void (*func)(), int argc, ...);

makecontext修改通过getcontext取得的上下文ucp(这意味着调用makecontext前必须先调用getcontext)。然后给该上下文指定一个栈空间ucp->stack，设置后继的上下文ucp->uc_link.

当上下文通过setcontext或者swapcontext激活后，执行func函数，argc为func的参数个数，后面是func的参数序列。当func执行返回后，继承的上下文被激活，如果继承上下文为NULL时，线程退出。

int swapcontext(ucontext_t *oucp, ucontext_t *ucp);

保存当前上下文到oucp结构体中，然后激活upc上下文。

如果执行成功，getcontext返回0，setcontext和swapcontext不返回；如果执行失败，getcontext,setcontext,swapcontext返回-1，并设置对于的errno.

简单说来，  getcontext获取当前上下文，setcontext设置当前上下文，swapcontext切换上下文，makecontext创建一个新的上下文。

4.小试牛刀-使用ucontext组件实现线程切换

虽然我们称协程是一个用户态的轻量级线程，但实际上多个协程同属一个线程。任意一个时刻，同一个线程不可能同时运行两个协程。如果我们将协程的调度简化为：主函数调用协程1，运行协程1直到协程1返回主函数，主函数在调用协程2，运行协程2直到协程2返回主函数。示意步骤如下：

[cpp]  view plain  copy
  1. 执行主函数  
  2. 切换：主函数 --> 协程1  
  3. 执行协程1  
  4. 切换：协程1  --> 主函数  
  5. 执行主函数  
  6. 切换：主函数 --> 协程2  
  7. 执行协程2  
  8. 切换协程2  --> 主函数  
  9. 执行主函数  
  10. ...  
这种设计的关键在于实现主函数到一个协程的切换，然后从协程返回主函数。这样无论是一个协程还是多个协程都能够完成与主函数的切换，从而实现协程的调度。

实现用户线程的过程是：

  1. 我们首先调用getcontext获得当前上下文
  2. 修改当前上下文ucontext_t来指定新的上下文，如指定栈空间极其大小，设置用户线程执行完后返回的后继上下文（即主函数的上下文）等
  3. 调用makecontext创建上下文，并指定用户线程中要执行的函数
  4. 切换到用户线程上下文去执行用户线程（如果设置的后继上下文为主函数，则用户线程执行完后会自动返回主函数）。

下面代码context_test函数完成了上面的要求。

[cpp]  view plain  copy
  1. #include <ucontext.h>  
  2. #include <stdio.h>  
  3.   
  4. void func1(void * arg)  
  5.   
  6.     puts("1");  
  7.     puts("11");  
  8.     puts("111");  
  9.     puts("1111");  
  10.   
  11.   
  12. void context_test()  
  13.   
  14.     char stack[1024*128];  
  15.     ucontext_t child,main;  
  16.   
  17.     getcontext(&child); //获取当前上下文  
  18.     child.uc_stack.ss_sp = stack;//指定栈空间  
  19.     child.uc_stack.ss_size = sizeof(stack);//指定栈空间大小  
  20.     child.uc_stack.ss_flags = 0;  
  21.     child.uc_link = &main;//设置后继上下文  
  22.   
  23.     makecontext(&child,(void (*)(void))func1,0);//修改上下文指向func1函数  
  24.   
  25.     swapcontext(&main,&child);//切换到child上下文，保存当前上下文到main  
  26.     puts("main");//如果设置了后继上下文，func1函数指向完后会返回此处  
  27.   
  28.   
  29. int main()  
  30.   
  31.     context_test();  
  32.   
  33.     return 0;  
  34.   

在context_test中，创建了一个用户线程child,其运行的函数为func1.指定后继上下文为main
func1返回后激活后继上下文，继续执行主函数。

保存上面代码到example-switch.cpp.运行编译命令:

g++ example-switch.cpp -o example-switch

执行程序结果如下

[cpp]  view plain  copy
  1. cxy@ubuntu:~$ ./example-switch  
  2. 1  
  3. 11  
  4. 111  
  5. ucontext-人人都可以实现的简单协程库

    libco协程库上下文切换原理详解

    写个百万级别full-stack小型协程库——原理介绍

    协程库libtask源码分析之架构篇

    c++ uconcontext.h实现协程

    C高级 跨平台协程库