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里面协程的接口。最后，说一下个人理解的协程的好处。
协程，能够把一个计算或是操作，分解成若干步，并且可以再任何一步停下来，并在需要的时候继续执行剩下的步骤。
这样的模型，给予了更细粒度的控制一个操作或是功能。
比如，一个非常耗时间的操作，被分步执行可以更好的控制程序响应。
比如，一个操作需要依赖各种条件，可以更好的处理条件不满足时候的情况。
也能够更好的把操作或是计算过程中的状态变化，与其它的状态变化交互。而然，程序运行的过程就是抽象数据和结构不断变化的过程，协程能够优雅自然的进行这个变化过程的需求。
这样的模型，给予了更细粒度的控制一个操作或是功能。
比如，一个非常耗时间的操作，被分步执行可以更好的控制程序响应。
比如，一个操作需要依赖各种条件，可以更好的处理条件不满足时候的情况。
也能够更好的把操作或是计算过程中的状态变化，与其它的状态变化交互。而然，程序运行的过程就是抽象数据和结构不断变化的过程，协程能够优雅自然的进行这个变化过程的需求。