Scheduler——调度者、计划者。从字面上我们就可以看出，这个类负责的是程序和数据的调度。在上一篇的主循环分析中，（ cocos2d-x 框架深入分析（一）—— MainLoop ：）我们可以看到底层循环中：CCDirector::drawScene(void) 方法中，有这样的一句代码：m_pScheduler->update(m_fDeltaTime) ，这句代码中CCScheduler对象调用了成员函数update方法。

  1.    // calculate "global" dt

  2.    calculateDeltaTime();//计算时间差

  4.    //tick before glClear: issue #533

  5.    if (! m_bPaused)    //如果不暂停，就更新数据

  6.    {

  7.        m_pScheduler->update(m_fDeltaTime);//调度者对象，是整个框架中，非常重要的东东，他负责者引擎中精灵、动作等的调度

  8.                                                                                   //而里面所用的数据结构的组织，一定程度决定者引擎的效率。

  9.    }

  11.    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  13.    /* to avoid flickr, nextScene MUST be here: after tick and before draw.

  14.     XXX: Which bug is this one. It seems that it can't be reproduced with v0.9 */

  15.    if (m_pNextScene)

  16.    {

  17.        setNextScene();//如果有m_pNextScene对象不为空，就说明需要调用到新的场景中，

  18.                                           //在其中onEnter()、onEnterTransitionDidFinish()等函数被回调。

  19.    }

  21.    kmGLPushMatrix();//opengl:把当前矩阵放到栈中，开始绘图工作

  23.    // draw the scene

  24.    if (m_pRunningScene)

  25.    {

  26.        m_pRunningScene->visit();//通过访问方法，去绘制场景中包含的每个层和每个层中的每个节点的draw，

  27.                                                                 //这里面是一个递归的过程,其中transform()方法实现，opengl矩阵的变化，移动，旋转等。

  28.    }

复制代码
从代码上看，这段代码是在我们绘制图形前调用的。
更新？到底要更新什么？一个方法就可以实现了所有我们需要更新的数据？代者疑问，我们不妨来猜测一下设计者的思路：
1、既然是在绘图前的，那应该是更新游戏场景中的数据，比如：每层的显隐，精灵的坐标，旋转角度、纹理地图坐标、一些动画等等。
2、一个方法就可以实习，我们不妨大胆的猜测里面用上的设计模式和数据组织。如果我们把用调度的对象加入CCScheduler中，让CCScheduler来管理，和调度对象，这样的模式有一点像观察者设计模式（个人理解，不一定对！-。-！），对于观察者模式，我的理解为：有一个被观察者（类似于这个CCScheduler），在类中的内部中有0到多个的观察者接口（比如一个精灵），当被观察者的状态有所变化时，被观察者调用某个通知方法时，就会调用内部的所有的观察者接口的方法，这样就可以实现我们想要的效果。
      好了，我们带着自己的猜想去看看源代码。在进入update方法前，我们先看看这个类维持的是什么数据吧。
      找到...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\CCScheduler.h

  1.    float m_fTimeScale;

  3.    //

  4.    // "updates with priority" stuff

  5.    //

  6.        // 权限越小越先被调度

  7.        // 记录权限小于0的链表CCActionManager就是被装入的第一个节点

  8.    struct _listEntry *m_pUpdatesNegList;        // list of priority < 0

  9.        // 记录权限等于0的链表，一般的节点是这个权限

  10.    struct _listEntry *m_pUpdates0List;            // list priority == 0

  11.        // 记录权限大于0的链表，最后被调度

  12.    struct _listEntry *m_pUpdatesPosList;        // list priority > 0

  15.        // 用于记录需要用Update方法的对象，这里是通过哈希表储存的，目的很明显，就是为了快速查找。

  16.        // 这里用的哈希表是在   ...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\support\data_support\uthash.h

  17.        // uthash.h<span style="font-family: Arial;">头文件中，是用C语言实现的。</span>

  18.        // _hashUpdateEntry是哈希表项头地址，其中KEY是需要调度的对象的指针。VALUE就是_hashUpdateEntry结构体

  19.    struct _hashUpdateEntry *m_pHashForUpdates; // hash used to fetch quickly the list entries for pause,delete,etc

  21.    // Used for "selectors with interval"

  22.        // 结构同上，只是记录的是 SEL_SCHEDULE类型回调

  23.    struct _hashSelectorEntry *m_pHashForTimers;

  24.        // 结构同上，记录当前要调度的目标

  25.    struct _hashSelectorEntry *m_pCurrentTarget;

  27.    bool m_bCurrentTargetSalvaged;

  28.    // If true unschedule will not remove anything from a hash. Elements will only be marked for deletion.

  29.    bool m_bUpdateHashLocked;

  30.    CCArray* m_pScriptHandlerEntries;

复制代码
这就是CCScheduler维持的数据。其中包涵3个链表和3个哈希项。由此可以看出，当我们向CCScheduler中添加一个调度对象时（实际也就是scheduleSelector(SEL_SCHEDULE pfnSelector, CCObject *pTarget, float fInterval, bool bPaused) 或者 scheduleUpdateForTarget(CCObject *pTarget, int nPriority, bool bPaused) 等方法）。我们现在看看scheduleUpdateForTarget这个方法，看看是怎么把调度对象加入CCScheduler中的。
进入...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\CCScheduler.cpp

  1. void CCScheduler::scheduleUpdateForTarget(CCObject *pTarget, int nPriority, bool bPaused)

  2. {

  3.        // 申请一个用于记录Update的哈希项空指针

  4.    tHashUpdateEntry *pHashElement = NULL;

  5.        // 把KEY=pTarget 放到m_pHashForUpdates哈希链表中查找，找到为pHashElement赋值，没找到依然为空。

  6.    HASH_FIND_INT(m_pHashForUpdates, &pTarget, pHashElement);

  7.    if (pHashElement)   // 存在这个值

  8.    {

  9. #if COCOS2D_DEBUG >= 1

  10.        CCAssert(pHashElement->entry->markedForDeletion,"");

  11. #endif

  12.        // TODO: check if priority has changed!

  13.        // 确保被调度对象不被删除，最后返回

  14.        pHashElement->entry->markedForDeletion = false;

  15.        return;

  16.    }

  18.    // most of the updates are going to be 0, that's way there

  19.    // is an special list for updates with priority 0

  20.        // 多数的更新操作的权限值为0。

  21.    if (nPriority == 0)

  22.    {

  23.        appendIn(&m_pUpdates0List, pTarget, bPaused);

  24.    }

  25.        // CCActionManager的更新权限是小于0的。

  26.    else if (nPriority < 0)

  27.    {

  28.        priorityIn(&m_pUpdatesNegList, pTarget, nPriority, bPaused);

  29.    }

  30.    else

  31.    {

  32.        // priority > 0

  33.        priorityIn(&m_pUpdatesPosList, pTarget, nPriority, bPaused);

  34.    }

  35. }

复制代码
从上面的代码可以看出，如果在哈希表中已经存在对应的值就不在插入了，否则就进行插入方法。appendIn和priorityIn的方法实现的原理差不多，只是priorityIn方法在插入时，是按照权限的大小排序插入的。现在我们进入appendIn函数看看。
进入：...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\CCScheduler.cpp

  1. void CCScheduler::appendIn(_listEntry **ppList, CCObject *pTarget, bool bPaused)

  2. {

  3.        //申请一个链表节点

  4.    tListEntry *pListElement = (tListEntry *)malloc(sizeof(*pListElement));

  6.    pListElement->target = pTarget;

  7.    pListElement->paused = bPaused;

  8.    pListElement->markedForDeletion = false;

  9.        //把链表节点插入链表中。DL_APPEND这个方法是在utlist.h文件中，用C语言写的一个链表

  10.    DL_APPEND(*ppList, pListElement);

  12.    // update hash entry for quicker access

  13.        // 申请一个哈希项，用于更新操作，可以快速查找。

  14.    tHashUpdateEntry *pHashElement = (tHashUpdateEntry *)calloc(sizeof(*pHashElement), 1);

  15.    pHashElement->target = pTarget;

  16.    pTarget->retain();

  17.    pHashElement->list = ppList;

  18.    pHashElement->entry = pListElement;

  19.        // 把KEY为target，VALUE为pHashElement，插入哈希表中

  20.    HASH_ADD_INT(m_pHashForUpdates, target, pHashElement);

  21. }

复制代码
这个方法就是简单的插入数据。具体的每个字段的含义，下次讲到
CCScheduler用到的数据结构时，具体讲。。。
下面我们看看最重要的
update方法：...\cocos2d-2.1rc0-x-2.1.2\cocos2dx\CCScheduler.cpp

  1. // main loop

  2. void CCScheduler::update(float dt)

  3. {

  4.    m_bUpdateHashLocked = true;

  6.    if (m_fTimeScale != 1.0f)

  7.    {

  8.        dt *= m_fTimeScale;

  9.    }

  11.    // Iterate over all the Updates' selectors

  12.    tListEntry *pEntry, *pTmp;

  14.        // 遍历每个权限小于0的链表，并调用他们的update方法

  15.    // updates with priority < 0

  16.    DL_FOREACH_SAFE(m_pUpdatesNegList, pEntry, pTmp)

  17.    {

  18.                // 不是暂定和删除状态就update

  19.        if ((! pEntry->paused) && (! pEntry->markedForDeletion))//如果不是暂停和删除标志

  20.        {

  21.            pEntry->target->update(dt);

  22.        }

  23.    }

  25.        // 遍历每个权限等于0的链表，并调用他们的update方法

  26.    // updates with priority == 0

  27.    DL_FOREACH_SAFE(m_pUpdates0List, pEntry, pTmp)

  28.    {

  29.                // 不是暂定和删除状态就update

  30.        if ((! pEntry->paused) && (! pEntry->markedForDeletion))

  31.        {

  32.            pEntry->target->update(dt);

  33.        }

  34.    }

  36.        // 遍历每个权限大于0的链表，并调用他们的update方法

  37.    // updates with priority > 0

  38.    DL_FOREACH_SAFE(m_pUpdatesPosList, pEntry, pTmp)

  39.    {

  40.                // 不是暂定和删除状态就update

  41.        if ((! pEntry->paused) && (! pEntry->markedForDeletion))

  42.        {

  43.            pEntry->target->update(dt);

  44.        }

  45.    }

  47.        // 遍历更新所有的定制的选择器，注意这里遍历的实际是哈希表，这是一个比较特殊的哈希表，在下次讲数据结构时会说

  48.    // Iterate over all the custom selectors

  49.    for (tHashTimerEntry *elt = m_pHashForTimers; elt != NULL; )

  50.    {

  51.        m_pCurrentTarget = elt;

  52.        m_bCurrentTargetSalvaged = false;

  54.        if (! m_pCurrentTarget->paused)

  55.        {

  56.                        // 一个周期回调

  57.            // The 'timers' array may change while inside this loop

  58.            for (elt->timerIndex = 0; elt->timerIndex < elt->timers->num; ++(elt->timerIndex))

  59.            {

  60.                                // 当前索引的Timer

  61.                elt->currentTimer = (CCTimer*)(elt->timers->arr[elt->timerIndex]);

  62.                elt->currentTimerSalvaged = false;

  64.                elt->currentTimer->update(dt);

  66.                                // 如果update方法调用后currentTimerSalvaged被改为true就取消当前Timer

  67.                if (elt->currentTimerSalvaged)

  68.                {

  69.                    // The currentTimer told the remove itself. To prevent the timer from

  70.                    // accidentally deallocating itself before finishing its step, we retained

  71.                    // it. Now that step is done, it's safe to release it.

  72.                    elt->currentTimer->release();

  73.                }

  75.                elt->currentTimer = NULL;

  76.            }

  77.        }

  79.        // elt, at this moment, is still valid

  80.        // so it is safe to ask this here (issue #490)

  81.                // 哈希表的下一个位置

  82.        elt = (tHashTimerEntry *)elt->hh.next;

  84.        // only delete currentTarget if no actions were scheduled during the cycle (issue #481)

  85.                // 当前目标对象没有动作需要调度就把他从哈希表中移除

  86.        if (m_bCurrentTargetSalvaged && m_pCurrentTarget->timers->num == 0)

  87.        {

  88.            removeHashElement(m_pCurrentTarget);

  89.        }

  90.    }

  92.    // Iterate over all the script callbacks

  93.    if (m_pScriptHandlerEntries)

  94.    {

  95.        for (int i = m_pScriptHandlerEntries->count() - 1; i >= 0; i--)

  96.        {

  97.            CCSchedulerScriptHandlerEntry* pEntry = static_cast<CCSchedulerScriptHandlerEntry*>(m_pScriptHandlerEntries->objectAtIndex(i));

  98.            if (pEntry->isMarkedForDeletion())

  99.            {

  100.                m_pScriptHandlerEntries->removeObjectAtIndex(i);

  101.            }

  102.            else if (!pEntry->isPaused())

  103.            {

  104.                pEntry->getTimer()->update(dt);

  105.            }

  106.        }

  107.    }

  109.    // delete all updates that are marked for deletion

  110.    // updates with priority < 0

  111.        // 依据权限把当前被设置为删除状态的目标对象，从哈希表中移除

  112.    DL_FOREACH_SAFE(m_pUpdatesNegList, pEntry, pTmp)

  113.    {

  114.        if (pEntry->markedForDeletion)

  115.        {

  116.            this->removeUpdateFromHash(pEntry);

  117.        }

  118.    }

  120.    // updates with priority == 0

  121.    DL_FOREACH_SAFE(m_pUpdates0List, pEntry, pTmp)

  122.    {

  123.        if (pEntry->markedForDeletion)

  124.        {

  125.            this->removeUpdateFromHash(pEntry);

  126.        }

  127.    }

  129.    // updates with priority > 0

  130.    DL_FOREACH_SAFE(m_pUpdatesPosList, pEntry, pTmp)

  131.    {

  132.        if (pEntry->markedForDeletion)

  133.        {

  134.            this->removeUpdateFromHash(pEntry);

  135.        }

  136.    }

  138.    m_bUpdateHashLocked = false;

  140.    m_pCurrentTarget = NULL;

  141. }

复制代码
现在我们基本都知道了引擎是怎么通过CCScheduler更新所有node的数据的了，其中引起注意的是Update方法是CCObject的虚函数。所以只要是继承CCObject实现Update方法的类，注册进CCScheduler中，我们就可以在Update方法中每帧更新自己的数据。甚至我们还可以注册自己的回调函数。可见CCScheduler设计的强大。