协程的几种实现方式及原理
协程又可以称为用户线程,微线程，可以将其理解为单个进程或线程中的多个 用户态线程 ，这些微线程在用户态进程控制和调度.协程的实现方式有很多种，包括
1 .使用glibc中的ucontext库实现
2 .利用汇编代码切换上下文
3 .利用C语言语法中的switch-case的奇淫技巧实现(protothreads)
4 .利用C语言的setjmp和longjmp实现
实际上，无论是上述 那种 方式实现协程,其原理是相同的，都是通过保存和恢复寄存器的状态，来进行各协程上下文的保存和切换。
协程较于函数和线程的优点
- 相比于函数:协程避免了传统的函数调用栈，几乎可以无限地递归
- 相比与线程:协程没有内核态的上下文切换，近乎可以无限并发。协程在用户态进程显式的调度，可以把异步操作转换为同步操作，也意味着不需要加锁,避免了加锁过程中不必要的开销。
进程,线程以及协程的设计都是为了并发任务可以更好的利用CPU资源，他们之间最大的区别在于CPU资源的使用上:
- 进程和线程的任务调度是由内核控制的，是抢占式的；
- 协程的任务调度是在用户态完成,需要代码里显式地将CPU交给其他协程,是协作式的
使用glibc中的ucontext库实现
2.ucontext初接触
利用ucontext提供的四个函数 getcontext(),setcontext(),makecontext(),swapcontext() 可以在一个进程中实现用户级的线程切换。
本节我们先来看ucontext实现的一个简单的例子：
[cpp] view plain copy
#include <stdio.h>
#include <ucontext.h>
#include <unistd.h>
int main(int argc, const char *argv[]){
ucontext_t context;
getcontext(&context);
puts("Hello world");
sleep(1);
setcontext(&context);
return 0;
} 注：示例代码来自维基百科.
保存上述代码到 example.c ,执行编译命令：
gcc example.c -o example
想想程序运行的结果会是什么样？
cxy@ubuntu:~$ ./example
Hello world
Hello world
Hello world
Hello world
Hello world
Hello world
Hello world
^C
cxy@ubuntu:~$ 上面是程序执行的部分输出，不知道是否和你想得一样呢？我们可以看到，程序在输出第一个“Hello world”后并没有退出程序，而是持续不断的输出”Hello world“。其实是程序通过getcontext先保存了一个上下文,然后输出”Hello world”,在通过setcontext恢复到getcontext的地方，重新执行代码，所以导致程序不断的输出”Hello world“，在我这个菜鸟的眼里，这简直就是一个神奇的跳转。
那么问题来了，ucontext到底是什么？
ucontext组件到底是什么
在类System V环境中,在头文件< ucontext.h > 中定义了两个结构类型， mcontext_t 和 ucontext_t 和四个函数 getcontext(),setcontext(),makecontext(),swapcontext() .利用它们可以在一个进程中实现用户级的线程切换。
mcontext_t 类型与机器相关，并且不透明. ucontext_t 结构体则至少拥有以下几个域:
typedef struct ucontext {
struct ucontext *uc_link;
sigset_t uc_sigmask;
stack_t uc_stack;
mcontext_t uc_mcontext;
...
} 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 创建一个新的上下文。
使用ucontext组件实现线程切换
虽然我们称协程是一个用户态的轻量级线程，但实际上多个协程同属一个线程。任意一个时刻，同一个线程不可能同时运行两个协程。如果我们将协程的调度简化为：主函数调用协程1，运行协程1直到协程1返回主函数，主函数 在 调用协程2，运行协程2直到协程2返回主函数。示意步骤如下：
- 执行主函数
- 切换：主函数 –> 协程1
- 执行协程1
- 切换：协程1 –> 主函数
- 执行主函数
- 切换：主函数 –> 协程2
- 执行协程2
- 切换协程2 –> 主函数
- 执行主函数
- …
这种设计的关键在于实现主函数到一个协程的切换，然后从协程返回主函数。这样无论是一个协程还是多个协程都能够完成与主函数的切换，从而实现协程的调度。
实现用户线程的过程是：
- 我们首先调用getcontext获得当前上下文
- 修改当前上下文ucontext_t来指定新的上下文，如指定栈空间极其大小，设置用户线程执行完后返回的后继上下文（即主函数的上下文）等
- 调用makecontext创建上下文，并指定用户线程中要执行的函数
- 切换到用户线程上下文去执行用户线程（如果设置的后继上下文为主函数，则用户线程执行完后会自动返回主函数）。
下面代码 context_test 函数完成了上面的要求。
- #include <ucontext.h>
- #include <stdio.h>
- void func1( void * arg)
- {
- puts( “1” );
- puts( “11” );
- puts( “111” );
- puts( “1111” );
- }
- void context_test()
- {
- char stack[1024*128];
- ucontext_t child,main;
- getcontext(&child); //获取当前上下文
- child.uc_stack.ss_sp = stack; //指定栈空间
- child.uc_stack.ss_size = sizeof (stack); //指定栈空间大小
- child.uc_stack.ss_flags = 0;
- child.uc_link = &main //设置后继上下文
- makecontext(&child,( void (*)( void ))func1,0); //修改上下文指向func1函数
- swapcontext(&main,&child); //切换到child上下文，保存当前上下文到main
- puts( “main” ); //如果设置了后继上下文，func1函数指向完后会返回此处
- }
- int main()
- {
- context_test();
- return 0;
- }
在context_test中，创建了一个用户线程child,其运行的函数为func1.指定后继上下文为main
func1返回后激活后继上下文，继续执行主函数。
保存上面代码到example-switch.cpp.运行编译命令:
g++ example-switch.cpp -o example-switch
执行程序结果如下
- cxy@ubuntu:~$ ./example- switch
- 1
- 11
- 111
- 1111
- main
- cxy@ubuntu:~$
你也可以通过修改后继上下文的设置，来观察程序的行为。如修改代码
child.uc_link = &main
为
child.uc_link = NULL;
再重新编译执行，其执行结果为：
- cxy@ubuntu:~$ ./example- switch
- 1
- 11
- 111
- 1111
- cxy@ubuntu:~$
可以发现程序没有打印”main”，执行为func1后直接退出，而没有返回主函数。可见，如果要实现主函数到线程的切换并返回，指定后继上下文是非常重要的
使用ucontext实现自己的线程库
掌握了上一节从主函数到协程的切换的关键，我们就可以开始考虑实现自己的协程了。
定义一个协程的结构体如下：
- typedef void (*Fun)( void *arg);
- typedef struct uthread_t
- {
- ucontext_t ctx;
- Fun func;
- void *arg;
- enum ThreadState state;
- char stack[DEFAULT_STACK_SZIE];
- }uthread_t;
ctx保存协程的上下文，stack为协程的栈，栈大小默认为DEFAULT_STACK_SZIE=128Kb.你可以根据自己的需求更改栈的大小。func为协程执行的用户函数，arg为func的参数，state表示协程的运行状态，包括FREE,RUNNABLE,RUNING,SUSPEND,分别表示空闲，就绪，正在执行和挂起四种状态。
在定义一个调度器的结构体
- typedef std::vector<uthread_t> Thread_vector;
- typedef struct schedule_t
- {
- ucontext_t main;
- int running_thread;
- Thread_vector threads;
- schedule_t():running_thread(-1){}
- }schedule_t;
调度器包括主函数的上下文main,包含当前调度器拥有的所有协程的vector类型的threads，以及指向当前正在执行的协程的编号running_thread.如果当前没有正在执行的协程时，running_thread=-1.
接下来，在定义几个使用函数uthread_create,uthread_yield,uthread_resume函数已经辅助函数schedule_finished.就可以了。
int uthread_create(schedule_t &schedule,Fun func,void *arg);
创建一个协程，该协程的会加入到schedule的协程序列中，func为其执行的函数，arg为func的执行函数。返回创建的线程在schedule中的编号。
void uthread_yield(schedule_t &schedule);
挂起调度器schedule中当前正在执行的协程，切换到主函数。
void uthread_resume(schedule_t &schedule,int id);
恢复运行调度器schedule中编号为id的协程
int schedule_finished(const schedule_t &schedule);
判断schedule中所有的协程是否都执行完毕，是返回1，否则返回0.注意：如果有协程处于挂起状态时算作未全部执行完毕，返回0.
代码就不全贴出来了，我们来看看两个关键的函数的具体实现。首先是uthread_resume函数：
- void uthread_resume(schedule_t &schedule , int id)
- {
- if (id < 0 || id >= schedule.threads.size()){
- return ;
- }
- uthread_t *t = &(schedule.threads[id]);
- switch (t->state){
- case RUNNABLE:
- getcontext(&(t->ctx));
- t->ctx.uc_stack.ss_sp = t->stack;
- t->ctx.uc_stack.ss_size = DEFAULT_STACK_SZIE;
- t->ctx.uc_stack.ss_flags = 0;
- t->ctx.uc_link = &(schedule.main);
- t->state = RUNNING;
- schedule.running_thread = id;
- makecontext(&(t->ctx),( void (*)( void ))(uthread_body),1,&schedule);
- /* !! note : Here does not need to break */
- case SUSPEND:
- swapcontext(&(schedule.main),&(t->ctx));
- break ;
- default : ;
- }
- }
如果指定的协程是首次运行，处于RUNNABLE状态，则创建一个上下文，然后切换到该上下文。如果指定的协程已经运行过，处于SUSPEND状态，则直接切换到该上下文即可。代码中需要注意RUNNBALE状态的地方不需要break.
- void uthread_yield(schedule_t &schedule)
- {
- if (schedule.running_thread != -1 ){
- uthread_t *t = &(schedule.threads[schedule.running_thread]);
- t->state = SUSPEND;
- schedule.running_thread = -1;
- swapcontext(&(t->ctx),&(schedule.main));
- }
- }
uthread_yield挂起当前正在运行的协程。首先是将running_thread置为-1，将正在运行的协程的状态置为SUSPEND，最后切换到主函数上下文。
更具体的代码我已经放到github上,点击这里。
使用我们自己的协程库
- #include “uthread.h”
- #include <stdio.h>
- void func2( void * arg)
- {
- puts( “22” );
- puts( “22” );
- uthread_yield(*(schedule_t *)arg);
- puts( “22” );
- puts( “22” );
- }
- void func3( void *arg)
- {
- puts( “3333” );
- puts( “3333” );
- uthread_yield(*(schedule_t *)arg);
- puts( “3333” );
- puts( “3333” );
- }
- void schedule_test()
- {
- schedule_t s;
- int id1 = uthread_create(s,func3,&s);
- int id2 = uthread_create(s,func2,&s);
- while (!schedule_finished(s)){
- uthread_resume(s,id2);
- uthread_resume(s,id1);
- }
- puts( “main over” );
- }
- int main()
- {
- schedule_test();
- return 0;
- }
执行编译命令并运行：
g++ example-uthread.cpp -o example-uthread./example-uthread 运行结果如下：
- cxy@ubuntu:~/mythread$./example-uthread
- 22
- 22
- 3333
- 3333
- 22
- 22
- 3333
- 3333
- main over
- cxy@ubuntu:~/mythread$
总结一下 ，我们利用getcontext和makecontext创建上下文，设置后继的上下文到主函数，设置每个协程的栈空间。在利用swapcontext在主函数和协程之间进行切换。
到此，使用ucontext做一个自己的协程库就到此结束了。相信你也可以自己完成自己的协程库了
一起学习的可以后台私信“资料”送相关学习资料可以一起学习交流大家也可以关注一下， Linux服务器架构师学习资料后台私信“资料”（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等等。。。），免费分享
