实现了一个简单的timer

对于游戏编程来说，timer是绝对不陌生的，不过以前一直使用一些库提供的timer，像sdl的timer，windows api提供的timer，这段时间突然觉得像这种东西还是在自己的游戏引擎里面实现一个，作为基本类库使用。

首先参考了一下linux的timer机制，详细见 http://www.linuxforum.net/forum/showthreaded.php?Cat=&Board=driver&Number=385224&page=0&view=collapsed&sb=5&o=all&vc=1
不过我实现的跟这个还是有点不一样的。

主要思想就是采用一个timer wheel，假设有一个timer的循环队列，队列上面的每个对象（我们叫做slot）是一个timer的list，现在我们处理到了第m轮第n个slot上面，这时候注册了一个timer，这个timer的间隔为interval毫秒，那么这个timer就应该放到第 n + interval / timer_interval (timer_interval为定时器的精度时间)的slot上面，然后挂在到该slot对应的list末尾，因为我们的环有长度，所以如果注册的timer interval时间很长，interval / timer_interval + n可能超出了wheel的长度，不过由于我们是一个环状结构，所以我们这个timer会在第 m + interval % timer_interval轮之后运行，同时是放到 (n + interval / timer_interval) % max_slotnum这个slot上面。

注册完成以后，当我们的处理到相应的slot的上面的时候，我们会一次的从list上面取出timer，然后现判断是否该timer是在该轮运行，不是则不处理，是则处理。如果碰到interval为0的timer，则会一直处理，知道该timer自己删除自己。

另外，由于我们的定时器有一个最小精度，所以除了interval为0的以外，其他的小于timer_interval的时间，我们全认为是timer_interval。

这个timer实现的非常简单，而且只能保证精度为timer_interval（一般也就是30ms），不过对于我来说，已经够了。

下面帖代码。

/**********************************************/
//BaseType.h
/**********************************************/
#pragma once
typedef char                        int8;
typedef short                       int16;
typedef int                         int32;
typedef long long                   int64;
typedef unsigned char               uint8;
typedef unsigned short              uint16;
typedef unsigned int                uint32;
typedef unsigned long long          uint64;
/**********************************************/
//CTimer.h
/**********************************************/
#pragma once
#include "BaseType.h"
#include <list>
class CTimer
{
friend class CTimerMgr;
public:
CTimer();
~CTimer();
virtual void OnTimer();
private:
uint32 m_uInterval;         //timer的间隔时间
uint32 m_uRing;             //第几轮运行
std::list<CTimer*>*  m_pTimerList;    //在当前哪个mgr list上面
std::list<CTimer*>::iterator m_itInList;  //在timer list上面对应的iteratoro

};
/**********************************************/
//CTimer.cpp
/**********************************************/
#include "CTimer.h"
#include <list>
using namespace std;
CTimer::CTimer()
: m_pTimerList(NULL),
m_uInterval(0),
m_uRing(0)
{

}
CTimer::~CTimer()
{
if(m_pTimerList)
m_pTimerList->erase(m_itInList);
}
void CTimer::OnTimer()
{
}

/**********************************************/
//CTimerMgr.h
/**********************************************/
#pragma once
#include "BaseType.h"
#include <vector>
#include <list>
class CTimer;
class CTimerMgr
{
friend class CTimer;
public:
CTimerMgr(uint32 uInterval, uint32 uSlotNum);
~CTimerMgr();
void RegisterTimer(CTimer* pTimer, uint32 uInterval);
void UnRegisterTimer(CTimer* pTimer);
void OnTimer();

private:
std::vector<std::list<CTimer*>* >    m_vecTimerContainer;
uint32  m_uInterval;
uint32  m_uSlotNum;
uint32  m_uRing;
uint32  m_uCurSlot;
};
/**********************************************/
//CTimerMgr.cpp
/**********************************************/
#include "CTimerMgr.h"
#include "CTimer.h"
#include <vector>
#include <list>
#include <assert.h>

using namespace std;
CTimerMgr::CTimerMgr(uint32 uInterval, uint32 uSlotNum)
: m_uInterval(uInterval),
m_uSlotNum(uSlotNum),
m_uRing(0),
m_uCurSlot(0)
{
for(int i = 0; i < uSlotNum; i++)
{
list<CTimer*>* pTimerList = new list<CTimer*>;
m_vecTimerContainer.push_back(pTimerList);
}
}
CTimerMgr::~CTimerMgr()
{
for(int i = 0; i < m_uSlotNum; i++)
{
list<CTimer*>* pTimerList = m_vecTimerContainer[i];
while(pTimerList->empty())
{
CTimer* pTimer = pTimerList->front();
delete pTimer;
}
delete pTimerList;
}
m_vecTimerContainer.clear();
}
void CTimerMgr::RegisterTimer(CTimer* pTimer, uint32 uInterval)
{
//除了0以外，timer的最小精度为m_uInterval
if(uInterval != 0 && uInterval < m_uInterval)
uInterval = m_uInterval;
uint32 uSlot = m_uCurSlot + uInterval / m_uInterval;

if(uSlot >= m_uSlotNum)
{
pTimer->m_uRing = m_uRing + uSlot / m_uSlotNum;
uSlot = uSlot % m_uSlotNum;
}
else
{
pTimer->m_uRing = m_uRing;
}

list<CTimer*>* pTimerList = m_vecTimerContainer[uSlot];
pTimer->m_pTimerList = pTimerList;
pTimer->m_uInterval = uInterval;
pTimerList->push_back(pTimer);
pTimer->m_itInList = --pTimerList->end();
}
void CTimerMgr::UnRegisterTimer(CTimer* pTimer)
{
if(!pTimer)
return;
list<CTimer*>* pTimerList = pTimer->m_pTimerList;
pTimerList->erase(pTimer->m_itInList);
pTimer->m_pTimerList = NULL;
delete pTimer;
}
void CTimerMgr::OnTimer()
{
list<CTimer*>* pTimerList = m_vecTimerContainer[m_uCurSlot];
list<CTimer*> NextTimerList;
while(!pTimerList->empty())
{
CTimer* pTimer = pTimerList->front();

if(pTimer->m_uRing != m_uRing)
{
NextTimerList.push_back(pTimer);
pTimerList->pop_front();
continue;
}
if(pTimer->m_uInterval == 0)
{
//不停调用，直到删除自己
while(!pTimer->m_pTimerList)
{
pTimer->OnTimer();
}
continue;
}
else
{
pTimer->OnTimer();
//如果timer删除了
if(!pTimer->m_pTimerList)
continue;
uint32 uSlot = pTimer->m_uInterval / m_uInterval;
assert(uSlot > 0);
uSlot += m_uCurSlot;

if(uSlot >= m_uSlotNum)
{
pTimer->m_uRing = m_uRing + uSlot / m_uSlotNum;
uSlot = uSlot % m_uSlotNum;
}
else
{
pTimer->m_uRing = m_uRing;
}
list<CTimer*>* pNewTimerList = m_vecTimerContainer[uSlot];
pTimerList->pop_front();
pNewTimerList->push_back(pTimer);
pTimer->m_pTimerList = pNewTimerList;
pTimer->m_itInList = --pNewTimerList->end();
}
}
pTimerList->swap(NextTimerList);

//移动到下一个slot，如果到了最后，则开始下一轮
++m_uCurSlot;
if(m_uCurSlot == m_uSlotNum)
{
m_uCurSlot = 0;
++m_uRing;
}
}