上篇文章分析到了定时器的定义。这篇的重点就是定时器是怎样执行起来的。

1.从main中寻找定时器的回调

讲定时器的执行，就不得不触及到cocos2dx的main函数了，由于定时器是主线程上执行的。并非单独线程的。所以它的调用必定会在main函数中，每帧调用。

下面代码就是win32平台下的main函数

int APIENTRY _tWinMain(HINSTANCE hInstance,
                       HINSTANCE hPrevInstance,
                       LPTSTR    lpCmdLine,
                       int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // create the application instance
    AppDelegate app;
    return Application::getInstance()->run();
}

int Application::run()
{
    while(!glview->windowShouldClose())
    {
        QueryPerformanceCounter(&nNow);
        if (nNow.QuadPart - nLast.QuadPart > _animationInterval.QuadPart)
        {
            nLast.QuadPart = nNow.QuadPart - (nNow.QuadPart % _animationInterval.QuadPart);
            
            director->mainLoop();		//看这里
            glview->pollEvents();
        }
        else
        {
            Sleep(1);
        }
    }
	return 0;
}

run函数中其它不相关的调用我已经去掉了，能够看到mainLoop函数才是真正的主循环

void DisplayLinkDirector::mainLoop()
{
    //做其它不相关的事情
	if (! _invalid)
    {
        drawScene();
    }
}

void Director::drawScene()
{
    if (! _paused)
    {
        _scheduler->update(_deltaTime);
        _eventDispatcher->dispatchEvent(_eventAfterUpdate);
    }
	//之后才进行绘制
}

这里能够看到，实际上运行的就是定时器的update函数。那么这个update函数中到底运行了什么东西呢？

2.定时器的update函数

首先来看看Update的代码

// main loop
void Scheduler::update(float dt)
{
    _updateHashLocked = true;

    if (_timeScale != 1.0f)
    {
        dt *= _timeScale;
    }

    //
    // 定时器回调
    //

    tListEntry *entry, *tmp;

    // Update定时器中优先级小于0的队列先运行
    DL_FOREACH_SAFE(_updatesNegList, entry, tmp)
    {
        if ((! entry->paused) && (! entry->markedForDeletion))
        {
            entry->callback(dt);
        }
    }

    // 接下来是优先级等于0的
    DL_FOREACH_SAFE(_updates0List, entry, tmp)
    {
        if ((! entry->paused) && (! entry->markedForDeletion))
        {
            entry->callback(dt);
        }
    }

    // 最后是大于0的
    DL_FOREACH_SAFE(_updatesPosList, entry, tmp)
    {
        if ((! entry->paused) && (! entry->markedForDeletion))
        {
            entry->callback(dt);
        }
    }

    // 这里循环的是自己定义定时器
    for (tHashTimerEntry *elt = _hashForTimers; elt != nullptr; )
    {
        _currentTarget = elt;
        _currentTargetSalvaged = false;

        if (! _currentTarget->paused)
        {
            // 遍历当前对象附属的全部定时器
            for (elt->timerIndex = 0; elt->timerIndex < elt->timers->num; ++(elt->timerIndex))
            {
                elt->currentTimer = (Timer*)(elt->timers->arr[elt->timerIndex]);
                elt->currentTimerSalvaged = false;

				//其实在这里运行真正的回调
                elt->currentTimer->update(dt);

                if (elt->currentTimerSalvaged)
                {
                    // 当定时器结束任务了。就应该释放掉
                    elt->currentTimer->release();
                }

                elt->currentTimer = nullptr;
            }
        }

        // 指向链表的下一对象
        elt = (tHashTimerEntry *)elt->hh.next;

        // 当对象的全部定时器已经运行完毕。而且对象附属的定时器为空，则将对象从哈希链表中移除
        if (_currentTargetSalvaged && _currentTarget->timers->num == 0)
        {
            removeHashElement(_currentTarget);
        }
    }

    // 移除全部标记为删除的优先级小于0的update定时器元素
    DL_FOREACH_SAFE(_updatesNegList, entry, tmp)
    {
        if (entry->markedForDeletion)
        {
            this->removeUpdateFromHash(entry);
        }
    }

    // 移除全部标记为删除的优先级等于0的update定时器元素
    DL_FOREACH_SAFE(_updates0List, entry, tmp)
    {
        if (entry->markedForDeletion)
        {
            this->removeUpdateFromHash(entry);
        }
    }

    // 移除全部标记为删除的优先级大于0的update定时器元素
    DL_FOREACH_SAFE(_updatesPosList, entry, tmp)
    {
        if (entry->markedForDeletion)
        {
            this->removeUpdateFromHash(entry);
        }
    }

    _updateHashLocked = false;
    _currentTarget = nullptr;
}

1. update定时器优先调用
2. update定时器中优先级越低的越优先调用
3. 自己定义定时器的回调在elt->currentTimer->update(dt);中运行

void Timer::update(float dt)
{
	// 初次运行 会进入到这个if中初始化
    if (_elapsed == -1)
    {
        _elapsed = 0;			//已运行时间
        _timesExecuted = 0;		//初始化反复次数
    }
    else
    {
        if (_runForever && !_useDelay)
        {//循环延时函数
            _elapsed += dt;
            if (_elapsed >= _interval)
            {
                trigger();		//真正的回调

                _elapsed = 0;
            }
        }    
        else
        {//advanced usage
            _elapsed += dt;
            if (_useDelay)		//延时
            {
                if( _elapsed >= _delay )
                {
                    trigger();		//真正的回调
                    
                    _elapsed = _elapsed - _delay;
                    _timesExecuted += 1;
                    _useDelay = false;
                }
            }
            else				//每帧调用
            {
                if (_elapsed >= _interval)
                {
                    trigger();		//真正的回调
                    
                    _elapsed = 0;
                    _timesExecuted += 1;

                }
            }

			//回调完毕，运行取消函数
            if (!_runForever && _timesExecuted > _repeat)
            {    //unschedule timer
                cancel();
            }
        }
    }
}

实际上核心的函数在

trigger();
cancel();

void TimerTargetSelector::trigger()
{
    if (_target && _selector)
    {
        (_target->*_selector)(_elapsed);
    }
}

void TimerTargetSelector::cancel()
{
    _scheduler->unschedule(_selector, _target);
}

以上就是定时器的实现原理分析的全过程，定时器的实如今文章中我感觉还是说的不是非常清楚。真正去代码中自己走一遍应该会更加明了，对以后的应用也会更得心应手。