C 语言实现协程

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里面协程的接口。最后，说一下个人理解的协程的好处。

协程，能够把一个计算或是操作，分解成若干步，并且可以再任何一步停下来，并在需要的时候继续执行剩下的步骤。

这样的模型，给予了更细粒度的控制一个操作或是功能。
比如，一个非常耗时间的操作，被分步执行可以更好的控制程序响应。
比如，一个操作需要依赖各种条件，可以更好的处理条件不满足时候的情况。

也能够更好的把操作或是计算过程中的状态变化，与其它的状态变化交互。而然，程序运行的过程就是抽象数据和结构不断变化的过程，协程能够优雅自然的进行这个变化过程的需求。