协程存在的原因？协程能够解决哪些问题？
在我们现在CS，BS开发模式下，服务器的吞吐量是一个很重要的参数。其实吞吐量是 IO 处理时间加上业务处理。
为了简单起见，比如，客户端与服务器之间是长连接的，客户端定期给服务器发送心跳包数据。客户端发送一次心跳包到服务器，服务器更新该新客户端状态的。心跳包发送的过程，业务处理时长等于IO读取（RECV系统调用）加上业务处理（更新客户状态）。吞吐量等于1s业务处理次数。
业务处理（更新客户端状态）时间，业务不一样的，处理时间不一样，我们就不做讨论。那如何提升recv的性能。
若只有一个客户端，recv的性能也没有必要提升，也不能提升。若在有百万计的客户端长连接的情况，我们该如何提升。以Linux为例，在这里需要介绍一个“网红”就是epoll。服务器使用epoll管理百万计的客户端长连接，代码框架如下：
while (1) {
int nready = epoll_wait(epfd, events, EVENT_SIZE, -1);
for (i = 0;i < nready;i ++) {
int sockfd = events[i].data.fd;
if (sockfd == listenfd) {
int connfd = accept(listenfd, xxx, xxxx);
setnonblock(connfd);
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = connfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
} else {
handle(sockfd);
}
}
}
对于响应式服务器，所有的客户端的操作驱动都是来源于这个大循环。来源于epoll_wait的反馈结果。对于服务器处理百万计的IO。Handle(sockfd)实现方式有两种。
第一种，handle(sockfd) 函数内部对 sockfd 进行读写动作。代码如下:
int handle(int sockfd) {
recv(sockfd, rbuffer, length, 0);
parser_proto(rbuffer, length);
send(sockfd, sbuffer, length, 0);
}
handle 的 io 操作（send,recv）与 epoll_wait 是在同一个处理流程里面的。这就是 IO 同步操作。
优点：
- sockfd 管理方便。
- 操作逻辑清晰。
缺点：
- 服务器程序依赖 epoll_wait 的循环响应速度慢。
- 程序性能差
第二种，handle(sockfd)函数内部将 sockfd 的操作，push 到线程池中，代码如下：
int thread_cb(int sockfd) {
// 此函数是在线程池创建的线程中运行。
// 与 handle 不在一个线程上下文中运行
recv(sockfd, rbuffer, length, 0);
parser_proto(rbuffer, length);
send(sockfd, sbuffer, length, 0);
}
int handle(int sockfd) {
//此函数在主线程 main_thread 中运行
//在此处之前，确保线程池已经启动。
push_thread(sockfd, thread_cb); //将 sockfd 放到其他线程中运行。
}
Handle 函数是将 sockfd 处理方式放到另一个已经其他的线程中运行，如此做法，将 io 操作（recv，send）与 epoll_wait 不在一个处理流程里面，使得 io 操作（recv,send）与 epoll_wait 实现解耦。这就叫做 IO 异步操作。
优点：
- 子模块好规划。
- 程序性能高。
缺点：
正因为子模块好规划，使得模块之间的 sockfd 的管理异常麻烦。每一个子线程都需要管理好 sockfd，避免在 IO 操作的时候，sockfd 出现关闭或其他异常。
上文有提到 IO 同步操作，程序响应慢，IO 异步操作，程序响应快。
C 语言实现协程，最困难的部分就是上下文信息的保存和还原。这样才能够做到，让协程在任意位置让出执行权限，稍后再恢复到中断位置继续执行。C 实现协程一般有几个方案。
使用第三方库来保存恢复上下文数据，比如ucontext
使用汇编来保存上下文信息
使用setjmp / longjmp 保存恢复上下文信息
使用switch case的特性来做上下文断点继续，上下文信息需要用static变量保存。比如Protothreads
使用线程来保存上下文信息
本文，使用了switch case的特性来保存中断位置，使用数据结构和static变量来保存上下文信息，使用宏来构建API调用。由于我使用过lua和unity c#协程进行了产品开发。所以，这套实现会贴近unity中C#的使用习惯。完成了一下功能：
在协程执行的任意位置暂停，让出执行权限
恢复协程继续上次中断的地方继续执行
通过static变量和数据结构保存协程数据
协程让出执行后，等待特定的帧数，时间，和其它协程完成
开始看代码：
typedef enum
{
/**
* Coroutine wait for frame count to waitValue
*/
coroutine_wait_frame,
/**
* Coroutine wait for second count to waitValue
*/
coroutine_wait_second,
/**
* Coroutine wait for other Coroutine to finish
*/
coroutine_wait_coroutine,
/**
* Coroutine just run forward
*/
coroutine_wait_none,
}
CoroutineWaitType;
先定义协程让出执行后，等待的类型。可以看到这里定义了几种类型，可以等待帧数，时间，其它协程。
typedef enum
{
/**
* Coroutine enter queue ready to running
*/
coroutine_state_ready,
/**
* Coroutine has started to execute
*/
coroutine_state_running,
/**
* Coroutine already finished and waiting for reuse
*/
coroutine_state_finish,
}
CoroutineState;
这里定义协程的状态。等待执行，正在执行包括中断的也算在执行的，还有执行完成的。我们后面会介绍，有一个协程管理器。所有的协程进入管理器，被轮询检测。完成后的协程会被缓存起来，下次请求协程的时候会先检查缓存的协程可否使用。
typedef struct Coroutine Coroutine;
typedef void (*CoroutineRun)(Coroutine* coroutine);
struct Coroutine
{
/**
* Record coroutine run step
*/
int step;
/**
* Coroutine implement function
*/
CoroutineRun Run;
/**
* Coroutine current state
*/
CoroutineState state;
/**
* Coroutine wait value to execute
*/
float waitValue;
/**
* Record wait progress
*/
float curWaitValue;
/**
* Coroutine wait types
*/
CoroutineWaitType waitType;
/**
* Hold params for CoroutineRun to get
* when coroutine finish clear but the param create memory control yourself
*/
ArrayList(void*) params[1];
/**
* Hold Coroutines wait for this Coroutine to finish
*/
ArrayList(Coroutine*) waits [1];
};
这里定以了一个协程的数据结构。CoroutineRun 就是一个C语言的函数，真正执行的协程函数。
step 用来保存CoroutineRun执行到哪一行了。下次继续这一行执行。后面会介绍，使用宏定义 __LINE__来捕获函数执行的函数，保存到step。
Run 就是执行的函数指针。
state 用来标示协程处在什么状态。
waitValue 表示协程等待的数值，帧数还是时间。
curWaitValue 就是当前等待了多少数值，这个值抵达waitValue表示协程等待结束了。
waitType 表示等待的类型。是等待帧数，还是时间，还是其它协程完成。
params 是绑定的一个动态数组，存放需要在协程函数里使用的参数。ArrayList是自定义类型，可以替换为其它相同实现。后面的()仅仅是一个空参数的宏定义。
waits 也是一个动态数组，存放的是等待当前协程的其它协程。也就是说有多个协程在等待这个协程，当这个协程完成的时候会释放等待队列的其它协程。这里并没有使用一个指针保存等待的协程，而是选择了保存等待自己的协程数组。因为协程使用了缓存系统，一个协程结束，就要进入缓存队列，依赖它的协程需要立马得到通知。
接下来，我们提供一组宏定义，用在 CoroutineRun 中，来完成协程的功能。
#define ACoroutineAddParam(coroutine, value) \
AArrayListAdd(coroutine->params, value)
/**
* return value
*/
#define ACoroutineGetParam(coroutine, index, type) \
AArrayListGet(coroutine->params, index, type)
/**
* return valuePtr
*/
#define ACoroutineGetPtrParam(coroutine, index, type) \
AArrayListGetPtr(coroutine->params, index, type)
这是在协程对象上绑定和获取数据，为了在协程函数内使用外部数据。就是使用协程对象的params数组。
#define ACoroutineBegin() \
switch (coroutine->step) \
{ \
case 0: \
coroutine->state = coroutine_state_running
#define ACoroutineEnd() \
} \
coroutine->state = coroutine_state_finish \
这两个宏是协程主体功能的开始和结束。在这两段之内的代码，可以通过后面提供的宏进行中断。这里是建立了一个switch case代码段，协程的代码处在这个代码段中，就可以利用case任意跳转。每次跳转的位置由step标识。
#define ACoroutineYieldFrame(waitFrameCount) \
coroutine->waitValue = waitFrameCount; \
coroutine->curWaitValue = 0.0f; \
coroutine->waitType = coroutine_wait_frame; \
coroutine->step = __LINE__; \
return; \
case __LINE__: \
#define ACoroutineYieldSecond(waitSecond) \
coroutine->waitValue = waitSecond; \
coroutine->curWaitValue = 0.0f; \
coroutine->waitType = coroutine_wait_second; \
coroutine->step = __LINE__; \
return; \
case __LINE__: \
#define ACoroutineYieldCoroutine(waitCoroutine) \
coroutine->waitValue = 0.0f; \
coroutine->curWaitValue = 0.0f; \
coroutine->waitType = coroutine_wait_coroutine; \
AArrayListAdd((waitCoroutine)->waits, coroutine); \
coroutine->step = __LINE__; \
return; \
case __LINE__: \
这里提供了，在begin和end之间中断的功能，等待帧数，等待时间，等待其它协程。原理是，使用这几个宏的时候，会用__LINE__赋值step，这样step就持有了当前行数变量。先return结束函数，在添加了case __LINE__，这样下次再次执行这个函数的时候，就会直接跳到上次return后的一个case上，继续执行。保存状态的变量需要使用static local变量保存，或是利用params传入。
#define ACoroutineYieldBreak() \
coroutine->state = coroutine_state_finish; \
return \
中断协程就是设置状态直接跳出。由于在begin和end中可能嵌套有循环，所以不能break，要直接return。
那看看怎么使用：
static void CRun(Coroutine* coroutine)
{
ACoroutineBegin();
ALogD("### begin");
ACoroutineYieldSecond(5.0f);
ALogD("### yield second 5");
ACoroutineYieldSecond(10.0f);
ALogD("### yield second 10");
ACoroutineYieldFrame(100.0f);
ALogD("### yield frame 100");
ACoroutineEnd();
}
void main()
{
ACoroutine->StartCoroutine(CRun);
}
只要在begin和end之间，使用Yield就可以让出执行流程，然后在返回接着执行。再次强调，需要保存进度的变量，需要使用params保存或是static local变量。那么，让出执行流程，是如何恢复的呢。那是因为所有协程都在一个协程管理器。协程管理器每帧都会执行控制协程的流程。代码如下。
struct ACoroutine
{
/**
* Bind CoroutineRun with Coroutine and enter queue ready to run
*/
Coroutine* (*StartCoroutine)(CoroutineRun Run);
/**
* Update on every frame
*/
void (*Update) (float deltaTime);
};
extern struct ACoroutine ACoroutine[1];
协程管理器，需要一个CoroutineRun函数就可以启动，然后在 CoroutineRun 中使用协程的功能。协程管理器的完整实现如下。
static ArrayIntMap(Coroutine*) coroutineMap [1] = AArrayIntMapInit(Coroutine*, 20);
static ArrayList (Coroutine*) coroutineList[1] = AArrayListInit (Coroutine*, 20);
static Coroutine* StartCoroutine(CoroutineRun Run)
{
Coroutine* coroutine = AArrayListPop(coroutineList, Coroutine*);
if (coroutine == NULL) {
coroutine = (Coroutine*) malloc(sizeof(Coroutine));
AArrayList->Init(sizeof(void*), coroutine->params);
coroutine->params->increase = 4;
AArrayList->Init(sizeof(Coroutine*), coroutine->waits);
coroutine->waits->increase = 4;
} else {
AArrayList->Clear(coroutine->params);
AArrayList->Clear(coroutine->waits);
}
coroutine->Run = Run;
coroutine->step = 0;
coroutine->waitValue = 0.0f;
coroutine->curWaitValue = 0.0f;
coroutine->waitType = coroutine_wait_none;
coroutine->state = coroutine_state_ready;
AArrayIntMapPut(coroutineMap, coroutine, coroutine);
return coroutine;
}
static void Update(float deltaTime)
{
for (int i = coroutineMap->arrayList->size - 1; i > -1; i--)
{
Coroutine* coroutine = AArrayIntMapGetAt(coroutineMap, i, Coroutine*);
if (coroutine->waitType == coroutine_wait_coroutine)
{
continue;
}
else if (coroutine->curWaitValue >= coroutine->waitValue)
{
coroutine->Run(coroutine);
if (coroutine->state == coroutine_state_finish)
{
AArrayIntMap->RemoveAt(coroutineMap, i);
// add to cache
AArrayListAdd(coroutineList, coroutine);
// set waiting coroutines execute forward
for (int j = 0; j < coroutine->waits->size; j++)
{
Coroutine* wait = AArrayListGet(coroutine->waits, j, Coroutine*);
ALogA
(
wait->state != coroutine_state_finish,
"Coroutine [%p] can not finish before wait coroutine [%p] finish",
wait, coroutine
);
wait->waitType = coroutine_wait_none;
}
continue;
}
}
else
{
switch (coroutine->waitType)
{
case coroutine_wait_frame:
coroutine->curWaitValue += 1.0f;
break;
case coroutine_wait_second:
coroutine->curWaitValue += deltaTime;
break;
}
}
}
}
struct ACoroutine ACoroutine[1] =
{
StartCoroutine,
Update,
};
代码量很少，Update函数需要每帧都调用。ArrayIntMap 和ArrayList 就是自定义的字典映射和动态数组。我在开发游戏中使用过lua和unity的C#中的协程。这套实现也是模拟了unity里面协程的接口。最后，说一下个人理解的协程的好处。
协程，能够把一个计算或是操作，分解成若干步，并且可以再任何一步停下来，并在需要的时候继续执行剩下的步骤。
这样的模型，给予了更细粒度的控制一个操作或是功能。
比如，一个非常耗时间的操作，被分步执行可以更好的控制程序响应。
比如，一个操作需要依赖各种条件，可以更好的处理条件不满足时候的情况。
也能够更好的把操作或是计算过程中的状态变化，与其它的状态变化交互。而然，程序运行的过程就是抽象数据和结构不断变化的过程，协程能够优雅自然的进行这个变化过程的需求。