c++ 简单模拟实现 游戏定时开启任务

// game_task.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <sys/timeb.h>
#include <time.h>
#include <process.h>
#include <map>
#include <assert.h>
using namespace std;

// time_test.cpp : 定义控制台应用程序的入口点。
//
/*
author:郑金玮
time:2014/07/19
desc:impl task manager
*/
//////////////////////////////////////////////////////////////////////////

class CThread
{
public:
CThread();
virtual ~CThread();

HANDLE getHandle() const;
bool wait();
bool wait(DWORD timeoutMillsecs);
void start();
DWORD terminate(DWORD exitcode=0);

private:

virtual int run() = 0;
static unsigned int __stdcall threadFunction(void *threadParam);
void resetHandle();
private:
CThread(const CThread&);
CThread& operator = (const CThread&);
private:
HANDLE m_handle;
};

CThread::CThread():m_handle(NULL)
{
}

CThread::~CThread()
{
resetHandle();
}

HANDLE CThread::getHandle() const
{
return m_handle;
}
void CThread::start()
{
if (m_handle == NULL)
{
unsigned int _threadID = 0;

m_handle = (HANDLE)::_beginthreadex(0,
0,
threadFunction,
(void*)this,
0,
&_threadID
);
assert(m_handle!=NULL);
}
}

bool CThread::wait()
{
return wait(INFINITE);
}
bool CThread::wait(DWORD timeoutMillsecs)
{
bool _isOK = false;

if (NULL == m_handle)
{
return true;
}

DWORD _result = ::WaitForSingleObject(m_handle,timeoutMillsecs);

if (_result == WAIT_TIMEOUT)
{
_isOK = false;
}
if (_result == WAIT_OBJECT_0)
{
_isOK = true;
}
resetHandle();

return _isOK;
}

DWORD CThread::terminate(DWORD exitcode)
{
if (m_handle != NULL && ::TerminateThread(m_handle,exitcode))
{
m_handle = NULL;
return ERROR_SUCCESS;
}
else
{
return ::GetLastError();
}
return 0;
}

unsigned int __stdcall CThread::threadFunction(void *threadParam)
{
CThread *pThread = (CThread*)threadParam;
int _ret = pThread->run();

pThread->resetHandle();
return _ret;
}
void CThread::resetHandle()
{
if (m_handle)
{
::CloseHandle(m_handle);
m_handle =NULL;
}
}

//////////////////////////////////////////////////////////////////////////

class CRealDateTime
{
public:
CRealDateTime():m_dif(0),m_dif2(0)
{}
~CRealDateTime(){}
private:
struct tm *m_t,m_t2;
time_t m_tb;
__int64 m_saveedTime;
public:
void calcTime() //计算当前时间到指定时间之间的时间差（秒级）
{
this->update();

m_saveedTime = m_dif2-m_dif;
}
__int64 getCalcTime()
{
return m_saveedTime;
}
void updateCalcTime(__int64 newTime)
{
m_saveedTime = newTime;
}
void setTime(int year,int month,int day,int hour,int minute,int sec) // set specify time
{
m_t2.tm_year = year - 1900;  //tm结构记录年为实际-1900
m_t2.tm_mon  = month - 1;
m_t2.tm_mday = day;
m_t2.tm_hour = hour;
m_t2.tm_min  = minute;
m_t2.tm_sec  = sec;
m_dif2=mktime(&m_t2);
}
void setTime(int hour,int minute,int sec)
{
::time(&m_tb);
struct tm *_t;
_t= ::localtime(&m_tb);
m_t2.tm_year = _t->tm_year;
m_t2.tm_mon  = _t->tm_mon ;
m_t2.tm_mday = _t->tm_mday;
m_t2.tm_hour = hour;
m_t2.tm_min  = minute;
m_t2.tm_sec  = sec;
m_dif2=mktime(&m_t2);
}
void update() //get current time
{
::time(&m_tb);
m_t= ::localtime(&m_tb);
m_dif=mktime(m_t);
}
__int64 gettime()
{
return m_dif;
}
void updateBegain(__int64 newBegain)
{
m_dif = newBegain;
}
__int64 get_now2Begain(__int64 t)
{
return t-m_dif;
}
private:
__int64 m_dif,m_dif2;
};

class CTimerManager
{
public:
__int64 getDiffTime(CRealDateTime *last,CRealDateTime *now)
{
__int64 __diff = now->gettime() - last->gettime();
return __diff;
}
public:
static CTimerManager* instance()
{
static CTimerManager __inst;
return &__inst;
}
};

#define TIMERMANAGER() CTimerManager::instance()

////////////////////////////////////////////////
class CAction
{
public:
CAction(){}
virtual ~CAction(){}
virtual	void process() = 0;
};

class CActionLogin : public CAction
{
public:
CActionLogin(){}
~CActionLogin(){}
public:
void process(){
cout<<"login  process...."<<endl;
}
};

class CActionGivePrize :public CAction
{
public:
CActionGivePrize(){}
~CActionGivePrize(){}
public:
void process(){
cout<<"givePrize  process...."<<endl;
}
};

//////////////////////////////////////////

class CTask
{
public:

void init(unsigned int nTaskID,CAction& action,CRealDateTime& objTime)
{
m_pAction = &action;
m_nTaskID = nTaskID;
m_TrrigleTime = &objTime;
m_bState = true;
}
bool getState(){ return m_bState ;}
void setState(bool state)
{
m_bState = state;
}
unsigned int getID(){ return m_nTaskID;}
bool checkTime(__int64 _nowEclps,__int64 _now)
{
__int64 _calctime = this->m_TrrigleTime->getCalcTime();
if (_calctime > 0)
{
_calctime -=_nowEclps;
if(_calctime<=0)
{
_calctime=0;
}
this->m_TrrigleTime->updateBegain(_now);
this->m_TrrigleTime->updateCalcTime(_calctime);
return false;
}
setState(false);//修改任务状态
return true;
}
void processevent()
{
m_pAction->process();
}
CRealDateTime* getTimer(){
return m_TrrigleTime;
}
private:

CAction* m_pAction;
unsigned int m_nTaskID;
CRealDateTime *m_TrrigleTime;
bool m_bState;
};

//////////////////////////////////////////////////////////////////////////
class CTaskManager :public CThread
{
CTaskManager(){
start();
}
~CTaskManager(){
terminate(0);
}
public:
static CTaskManager* instance()
{
static CTaskManager __instance;
return &__instance;
}
public:
bool add(CTask &task)
{
unsigned int _nTaskID = task.getID();
m_typeMapTask::iterator _itor = m_mapTask.find(_nTaskID);
m_typeMapTask::iterator _end = m_mapTask.end();

if (_itor != _end)
{
return false;
}
m_mapTask.insert(make_pair<unsigned int,CTask*>(_nTaskID,&task));
return true;
}
bool close(unsigned int nTaskID)
{
m_typeMapTask::iterator _itor = m_mapTask.find(nTaskID);
m_typeMapTask::iterator _end = m_mapTask.end();

if (_itor != _end)
{
m_mapTask.erase(_itor);
return true;
}
return false;
}
bool close(CTask &task)
{
unsigned int _nTaskID = task.getID();
m_typeMapTask::iterator _itor = m_mapTask.find(_nTaskID);
m_typeMapTask::iterator _end = m_mapTask.end();

if (_itor != _end)
{
m_mapTask.erase(_itor);
return true;
}
return false;
}
bool triggle(CTask &task)//定时器触发
{
//判断逻辑
CRealDateTime _now;
_now.update(); //保存当前时间
__int64 _nowDif = _now.gettime(); //获取当前时间的时间戳
__int64  _Eclpse= task.getTimer()->get_now2Begain(_nowDif);//获取当前时间到任务开始加入时的时间差
if( (task.getState()) && (task.checkTime(_Eclpse,_nowDif)))
{
task.processevent();
return true;
}
return false;
}
bool triggle(unsigned int nTaskID) //主动触发
{
m_typeMapTask::iterator _itor = m_mapTask.find(nTaskID);
m_typeMapTask::iterator _end = m_mapTask.end();

if (_itor != _end)
{
return triggle(*(_itor->second));
}
return false;
}
int run()//定时器在这里处理
{
while(true)
{
m_typeMapTask::iterator _begain = m_mapTask.begin();
m_typeMapTask::iterator _end      = m_mapTask.end();

m_typeMapTask::iterator _itor;
for (_itor = _begain;_itor != _end ;_itor++)
{
triggle(*(_itor->second));
}
}
return 0;
}
private:
typedef map<unsigned int,CTask*> m_typeMapTask;
m_typeMapTask m_mapTask;
};

#define  TASKMANAGER() CTaskManager::instance()

#define SAFE_RELEASE(point) \
{ \
delete point; \
point = 0; \
}

int _tmain(int argc, _TCHAR* argv[])
{

CRealDateTime timer1;
timer1.setTime(16,44,20);
timer1.calcTime();

CAction *paction = new CActionLogin();
CTask task;

task.init(1,*paction,timer1);
TASKMANAGER()->add(task);

//////////////////////////////////////////////////////////////////////////
CRealDateTime timer2;
timer2.setTime(2014,7,19,16,44,30);
timer2.calcTime();

CAction *paction2 = new CActionGivePrize();
CTask task2;

task2.init(2,*paction2,timer2);
TASKMANAGER()->add(task2);

while (true);

SAFE_RELEASE(paction);
SAFE_RELEASE(paction2);
return 0;
}