C++编码实现定时任务执行功能

//本文记录了自己实现过的一个定时执行任务的功能，以方便后续查阅。
//设计上使用接口编程思想，通过功能类对下实现功能接口，对上提供业务接口，达到业务与功能分离的目的。
//可根据实际情况，在任务管理者内部提供单线程轮询队列执行任务，同时增加线程池对每个任务进行调度执行以达到并发执行的目的。

#ifndef __TIMER_TASK_H__
#define __TIMER_TASK_H__

#include <map>
#include <mutex>
#define  SYNC_USRDATA_TASKID     1

class   ITask;
typedef unsigned int           U32;
typedef unsigned long long     U64;

//计时器
class Timer
{
public:
	Timer(void)
	{
		Reset();
	}
public:	
	void Reset()
	{
		struct timeval tv;
		gettimeofday(&tv,NULL);
		m_time = tv.tv_sec*1000 + tv.tv_usec/1000;
	}

	//毫秒
	U64  Elapsed()
	{
		struct timeval tv;
		gettimeofday(&tv,NULL);
		U64 cur_time = tv.tv_sec*1000 + tv.tv_usec/1000;
		return cur_time - m_time;
	}
private:
	U64 m_time;
};


//Task接口类，任何功能类都可以继承ITask来实现特有的功能
class ITask
{
public:
	ITask(U32 taskid):m_taskid(taskid){}
	virtual ~ITask(){}
	virtual void Execute(void *args)=0;

public:
	U32 m_taskid; 
};

//定时器功能类，实现功能接口，同时提供出上层业务类接口
class TimerTask : public ITask
{
public:
	TimerTask(U32 taskid,U32 interval):ITask(taskid), m_interval(interval){}
	virtual ~TimerTask(){}

	//实现定时执行功能
	virtual void Execute(void *args)
	{
		if(m_time.Elapsed() >= m_interval)
		{
			m_time.Reset();
			this->OnTimerTask(args);
		}
	}

	//提供给上层业务接口
	virtual void OnTimerTask(void *args)
	{
		//nothing
	}

private:
	U32   m_interval;
	Timer m_time;
};

//同步用户数据的业务类实现业务接口
class SyncUsrDataTask : public TimerTask
{
public:
	SyncUsrDataTask(U32 taskid,U32 interval):TimerTask(taskid,interval){}
	virtual void OnTimerTask(void *args)
	{
		printf("SyncUsrDataTask::OnTimerTask \n");
		//todo
	}

private:
};


//单例任务管理者
class TaskManager
{
public:
	typedef  std::map<U32,ITask*>  KdmcTaskMap;  //任务队列
public:
	static TaskManager* Instance()
	{
		if(NULL == m_instance)
		{
			m_instance = new TaskManager;
		}

		return m_instance;
	}

protected:
	TaskManager(){};
	~TaskManager(){};

private:
	static TaskManager* m_instance;

public:	
	//初始化任务，可添加定时任务与其他任务
	void TaskManager::InitTask()
	{	
		AddTask(new SyncUsrDataTask(SYNC_USRDATA_TASKID,60*1000));
	}

	void AddTask(ITask *task)
	{
		m_mutex.lock();
		m_taskmap.insert(KdmcTaskMap::value_type(task->m_taskid,task));
		m_mutex.unlock();
	}
	
	//轮询执行任务
	void ExecuteTask()
	{
		m_mutex.lock();
		KdmcTaskMap::iterator iter = m_taskmap.begin();
		for(; iter != m_taskmap.end(); iter++)
		{
			ITask *task = iter->second;
			if(task)
			{
				task->Execute(this);
			}
		}
		m_mutex.unlock();
	}

private:
	std::mutex   m_mutex;
	KdmcTaskMap  m_taskmap;
};


//cpp
TaskManager* TaskManager::m_instance = NULL;

int main(int argc, char* argv[])
{
	TaskManager::Instance()->InitTask();

	TaskManager::Instance()->ExecuteTask();

	return 0;
}


#endif