话不多说,直接看实现源码。
// 单线程模型,自增减没有互斥处理
class SingleThread
{
public:
static long _Increment(long* p){ return ++(*p); }
static long _Decrement(long* p){ return --(*p); }
};
// 计数器类
template<class ThreadModel = SingleThread>
class Counter
{
public:
Counter() : _m_val(0){}
long _Increment(){ return ThreadModel::_Increment(&_m_val); }
long _Decrement(){ return ThreadModel::_Decrement(&_m_val); }
long _GetCount(){ return _m_val; }
private:
long _m_val;
};
template<class T>
class _MemPtr : public T
{
public:
_MemPtr(){}
private:
long _Increment();
long _Decrement();
};
// 普通对象智能指针模板类,参数T必须从Counter继承
template<class T>
class MemPtr
{
public:
MemPtr() : m_p(NULL){}
MemPtr(T* p) : m_p(p){ AddRef(); } // ,
MemPtr(const MemPtr<T>& s) : m_p(s.m_p){ AddRef(); }
~MemPtr(){ Release(); }
MemPtr<T>& operator=(const MemPtr<T>& r)
{
if(m_p != r.m_p){ Release(); m_p = r.m_p; AddRef(); }
return *this;
}
operator T*() { return m_p; }
_MemPtr<T>* operator->() const { return (_MemPtr<T>*)m_p; }
bool operator==(const MemPtr<T>& r) const{ return m_p == r.m_p; }
bool operator!=(const MemPtr<T>& r) const{ return m_p != r.m_p; }
bool operator!() const{ return !m_p; }
operator bool() const{ return m_p != NULL; }
void Attach(T* p){ Release(); m_p = p; }
T* Detach(){ T* p = m_p; m_p = NULL; return p; }
void Release()
{
if(m_p)
{
if(m_p->_Decrement() == 0){ delete m_p; }
m_p = NULL;
}
}
T* Copy() { AddRef(); return m_p; }
long GetRef() const // Used for debugging
{
if(m_p) return m_p->_GetCount(); return -1;
}
T* m_p; // 请勿直接改写此变量
protected:
void AddRef(){ if(m_p) m_p->_Increment(); }
};
typedef unsigned long ULONG;
typedef unsigned __int64 UINT64;
class CTimer
{
public:
CTimer(){}
~CTimer(){}
public:
void RegisterTimer( UINT64 id, ULONG period, UINT64 times );
void UnRegisterTimer( UINT64 id );
void RunTimer();
private:
struct _TimerInfo : public Counter<>
{
ULONG ulLastTime;
ULONG ulNextTime;
ULONG ulPeriod;
UINT64 uiTimes;
_TimerInfo():uiTimes(0),ulLastTime(0),ulNextTime(0),ulPeriod(0){}
};
typedef map< UINT64, SmartPointer<_TimerInfo> >_TimerMap;
_TimerMap m_timer;
static UINT64 m_id;
};
UINT64 CTimer::m_id = 0;
void CTimer::RegisterTimer( UINT64 id, ULONG period, UINT64 times )
{
SmartPointer<_TimerInfo> timer(new _TimerInfo);
timer->ulLastTime = ::GetTickCount();
timer->ulNextTime = timer.m_p->ulLastTime + period;
timer->ulPeriod = period;
timer->uiTimes = times;
//m_id += 1;
m_timer.insert(make_pair(id, timer));
}
void CTimer::UnRegisterTimer(UINT64 id)
{
_TimerMap::iterator iter = m_timer.find(id);
if( iter != m_timer.end())
{
m_timer.erase(id);
}
}
void CTimer::RunTimer()
{
while( 1 )
{
_TimerMap::iterator iter = m_timer.begin();
for( ;iter != m_timer.end(); ++iter)
{
ULONG now = ::GetTickCount();
if( now >= iter->second->ulNextTime )
{
if( m_id == 3 ) break;
printf("timer id is:%d\n",iter->first);
iter->second->ulLastTime = now;
iter->second->ulNextTime = now + iter->second->ulPeriod;
m_id += 1;
}
}
}
}
int _tmain(int argc, _TCHAR* argv[])
{
CTimer timer;
//timer.RegisterTimer(1, 1000, 5);
timer.RegisterTimer(2, 2000, 3);
timer.RunTimer();
return 0;
}