前言
现在C++的开发开始流行使用coroutine，也就是协程。我看腾讯的几个开源项目里面都有协程的实现。使用协程可以用同步的写法，达到异步的性能。它的基本原理其实就是在IO等待的时候切换出去，在适当的时刻再切换回来。云风用200行代码实现了一个最简单的协程，我们先看这个代码了解一下协程的原理，然后再看微信的libco实现。
##协程简单介绍
协程可以理解为一个用户级的线程，一个线程里跑多个协程。协程分为对称协程和非对称协程，对称协程就是当协程切换的时候他可以切换到任意其他的协程，比如goroutine，而非对称协程只能切换到调用他的调度器。这里实现的是一个非对称协程。
coroutine源码分析
详细的注释代码在coroutine源码注释
我们先来看一下头文件1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct schedule; //协程调度器
typedef void (*coroutine_func)(struct schedule *, void *ud); //协程执行函数
struct schedule * coroutine_open(void); //创建协程调度器
void coroutine_close(struct schedule *); //关闭协程调度器
int coroutine_new(struct schedule *, coroutine_func, void *ud); //用协程调度器创建一个协程
void coroutine_resume(struct schedule *, int id); //恢复id号协程
int coroutine_status(struct schedule *, int id); //返回id号协程的状态
int coroutine_running(struct schedule *); //返回正在执行的协程id
void coroutine_yield(struct schedule *); //保存上下文后中断当前协程执行
整个实现就这么几个函数。用法就是先使用coroutine_open创建协程调度器，然后coroutine_new协程，在协程中使用coroutine_yield中断执行，同一个线程中使用coroutine_resume恢复协程执行。
接下来我们看具体的实现。
由于协程切换时需要保存当前上下文环境，这里用到了ucontext这个库，它有四个函数。1
2
3
4
5
6
7
8
9
10
11typedef struct ucontext { //上下文结构体
struct ucontext *uc_link; // 该上下文执行完时要恢复的上下文
sigset_t uc_sigmask;
stack_t uc_stack; //使用的栈
mcontext_t uc_mcontext;
...
} ucontext_t;
int getcontext(ucontext_t *ucp); //将当前上下文保存到ucp
int setcontext(const ucontext_t *ucp); //切换到上下文ucp
void makecontext(ucontext_t *ucp, void (*func)(), int argc, ...); //修改上下文入口函数
int swapcontext(ucontext_t *oucp, ucontext_t *ucp); //保存当前上下文到oucp，切换到上下文ucp
源码中比较简单的函数就不说了，重点说几个难理解的地方。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30void
coroutine_resume(struct schedule * S, int id) {
assert(S->running == -1);
assert(id >=0 && id < S->cap);
struct coroutine *C = S->co[id];
if (C == NULL)
return;
int status = C->status;
switch(status) {
case COROUTINE_READY: //如果状态是ready也就是第一次创建
getcontext(&C->ctx); //获取当前上下文
C->ctx.uc_stack.ss_sp = S->stack; //将协程栈设置为调度器的共享栈
C->ctx.uc_stack.ss_size = STACK_SIZE; //设置栈容量 使用时栈顶栈底同时指向S->stack+STACK_SIZE，栈顶向下扩张
C->ctx.uc_link = &S->main; //将返回上下文设置为调度器的上下文，协程执行完后会返回到main上下文
S->running = id; //设置调度器当前运行的协程id
C->status = COROUTINE_RUNNING; //设置协程状态
uintptr_t ptr = (uintptr_t)S;
makecontext(&C->ctx, (void (*)(void)) mainfunc, 2, (uint32_t)ptr, (uint32_t)(ptr>>32));//重置上下文执行mainfunc
swapcontext(&S->main, &C->ctx); //保存当前上下文到main，跳转到ctx的上下文
break;
case COROUTINE_SUSPEND: //如果状态时暂停也就是之前yield过
memcpy(S->stack + STACK_SIZE - C->size, C->stack, C->size); //将协程之前保存的栈拷贝到调度器的共享栈
S->running = id;
C->status = COROUTINE_RUNNING;
swapcontext(&S->main, &C->ctx); //同上
break;
default:
assert(0);
}
}
resume函数回复协程的运行，协程运行时使用共享栈，中断时将栈保存到私有栈中。
所谓的共享栈，就是将协程所使用的栈设为调度器的栈，由于S->stack为低地址，S->stack+STACK_SIZE为高地址，使用时，栈顶栈底同时指向S->stack+STACK_SIZE，栈顶向低地址扩张。当yield时将已使用的栈拷贝到协程的私有栈当中，resume时将私有栈拷贝到S->stack中。
这样做的好处是一个协程可以使用的栈空间很大，而且不会有提前分配导致的空间过大和浪费，只是拷贝对性能略有些影响。1
2C->ctx.uc_stack.ss_sp = S->stack; //将协程栈设置为调度器的共享栈
C->ctx.uc_stack.ss_size = STACK_SIZE; //设置栈容量,使用时栈顶栈底同时指向S->stack+STACK_SIZE，栈顶向下扩张
这两行将协程栈设置为共享栈。1
2
3
4
5
6
7
8
9
10
11
12static void
_save_stack(struct coroutine *C, char *top) { //top为栈底
char dummy = 0; //这里定义一个char变量，dummy地址为栈顶
assert(top - &dummy <= STACK_SIZE); //dummy地址减栈底地址为当前使用的栈大小
if (C->cap < top - &dummy) { //如果当前协程栈大小小于已用大小，重新分配
free(C->stack);
C->cap = top-&dummy;
C->stack = malloc(C->cap);
}
C->size = top - &dummy;
memcpy(C->stack, &dummy, C->size); //将共享栈拷贝到协程栈
}
这是保存栈的函数，这里用了一个很巧妙的方法，定义了一个局部变量dummy，此时dummy的地址应该是栈顶，而top是栈底，这样我们就知道当前协程使用的栈的大小。注意memcpy是从低地址开始拷贝的。
剩下的代码就很简单了，我在github上对源码进行了详细的注释，只要理解了保存栈的过程应该就没什么难度了。