码迷，mamicode.com
首页 > 其他好文 > 详细

网狐定时器引擎分析

时间：2015-07-03 09:19:05      阅读：1092      评论：0      收藏：0      [点我收藏+]

标签：

先贴出来网狐源码：

#ifndef WH_THREAD_HEAD_FILE
#define WH_THREAD_HEAD_FILE

#pragma once

#include "ServiceCoreHead.h"

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

//线程对象
class SERVICE_CORE_CLASS CWHThread
{
	//状态变量
private:
	volatile bool					m_bRun;								//运行标志

	//线程变量
private:
	UINT							m_uThreadID;						//线程标识
	HANDLE							m_hThreadHandle;					//线程句柄

	//函数定义
protected:
	//构造函数
	CWHThread();
	//析构函数
	virtual ~CWHThread();

	//接口函数
public:
	//获取状态
	virtual bool IsRuning();
	//启动线程
	virtual bool StartThread();
	//终止线程
	virtual bool ConcludeThread(DWORD dwMillSeconds);

	//功能函数
public:
	//线程标识
	UINT GetThreadID() { return m_uThreadID; }
	//线程句柄
	HANDLE GetThreadHandle() { return m_hThreadHandle; }
	//投递消息
	LRESULT PostThreadMessage(UINT uMessage, WPARAM wParam, LPARAM lParam);

	//事件函数
protected:
	//运行事件
	virtual bool OnEventThreadRun() { return true; }
	//开始事件
	virtual bool OnEventThreadStrat() { return true; }
	//终止事件
	virtual bool OnEventThreadConclude() { return true; }

	//内部函数
private:
	//线程函数
	static unsigned __stdcall ThreadFunction(LPVOID pThreadData);
};

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

#endif


#include "StdAfx.h"
#include "WHThread.h"

//////////////////////////////////////////////////////////////////////////////////
//结构定义

//启动参数
struct tagThreadParameter
{
	bool							bSuccess;							//是否错误
	HANDLE							hEventFinish;						//事件句柄
	CWHThread	*				pServiceThread;						//线程指针
};

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

//构造函数
CWHThread::CWHThread()
{
	//设置变量
	m_bRun=false;
	m_uThreadID=0;
	m_hThreadHandle=NULL;

	return;
}

//析构函数
CWHThread::~CWHThread()
{
	//停止线程
	ConcludeThread(INFINITE);

	return;
}

//状态判断
bool CWHThread::IsRuning()
{
	//运行检测
	if (m_hThreadHandle==NULL) return false;
	if (WaitForSingleObject(m_hThreadHandle,0)!=WAIT_TIMEOUT) return false;

	return true;
}

//启动线程
bool CWHThread::StartThread()
{
	//效验状态
	ASSERT(IsRuning()==false);
	if (IsRuning()==true) return false;

	//清理变量
	if (m_hThreadHandle!=NULL) 
	{
		//关闭句柄
		CloseHandle(m_hThreadHandle);

		//设置变量
		m_uThreadID=0;
		m_hThreadHandle=NULL;
	}
 
	//变量定义
	tagThreadParameter ThreadParameter;
	ZeroMemory(&ThreadParameter,sizeof(ThreadParameter));

	//设置变量
	ThreadParameter.bSuccess=false;
	ThreadParameter.pServiceThread=this;
	ThreadParameter.hEventFinish=CreateEvent(NULL,FALSE,FALSE,NULL);

	//效验状态
	ASSERT(ThreadParameter.hEventFinish!=NULL);
	if (ThreadParameter.hEventFinish==NULL) return false;
	
	//启动线程
	m_bRun=true;
	m_hThreadHandle=(HANDLE)::_beginthreadex(NULL,0,ThreadFunction,&ThreadParameter,0,&m_uThreadID);

	//错误判断
	if (m_hThreadHandle==INVALID_HANDLE_VALUE)
	{
		CloseHandle(ThreadParameter.hEventFinish);
		return false;
	}

	//等待事件
	WaitForSingleObject(ThreadParameter.hEventFinish,INFINITE);
	CloseHandle(ThreadParameter.hEventFinish);

	//判断错误
	if (ThreadParameter.bSuccess==false)
	{
		ConcludeThread(INFINITE);
		return false;
	}

	return true;
}

//停止线程
bool CWHThread::ConcludeThread(DWORD dwMillSeconds)
{
	//停止线程
	if (IsRuning()==true)
	{
		//设置变量
		m_bRun=false;

		//停止等待
		if (WaitForSingleObject(m_hThreadHandle,dwMillSeconds)==WAIT_TIMEOUT)
		{
			return false;
		}
	}

	//设置变量
	if (m_hThreadHandle!=NULL)
	{
		//关闭句柄
		CloseHandle(m_hThreadHandle);

		//设置变量
		m_uThreadID=0;
		m_hThreadHandle=NULL;
	}

	return true;
}

//投递消息
LRESULT CWHThread::PostThreadMessage(UINT uMessage, WPARAM wParam, LPARAM lParam)
{
	//状态效验
	ASSERT((m_uThreadID!=0)&&(m_hThreadHandle!=NULL));
	if ((m_uThreadID==0)||(m_hThreadHandle==NULL)) return false;

	//投递消息
	if (::PostThreadMessage(m_uThreadID,uMessage,wParam,lParam)==FALSE)
	{
		DWORD dwLastError=GetLastError();
		return dwLastError;
	}

	return 0L;
}

//线程函数
unsigned __stdcall CWHThread::ThreadFunction(LPVOID pThreadData)
{
	//随机种子
	srand((DWORD)time(NULL));

	//变量定义
	tagThreadParameter * pThreadParameter=(tagThreadParameter *)pThreadData;
	CWHThread * pServiceThread=pThreadParameter->pServiceThread;

	//启动通知
	try
	{
		pThreadParameter->bSuccess=pServiceThread->OnEventThreadStrat(); 
	} 
	catch (...)
	{
		//设置变量
		ASSERT(FALSE);
		pThreadParameter->bSuccess=false;
	}

	//设置事件
	bool bSuccess=pThreadParameter->bSuccess;
	ASSERT(pThreadParameter->hEventFinish!=NULL);
	if (pThreadParameter->hEventFinish!=NULL) SetEvent(pThreadParameter->hEventFinish);

	//线程处理
	if (bSuccess==true)
	{
		//线程运行
		while (pServiceThread->m_bRun)
		{
#ifndef _DEBUG
			//运行版本
			try
			{
				if (pServiceThread->OnEventThreadRun()==false)
				{
					break;
				}
			}
			catch (...)	{ }
#else
			//调试版本
			if (pServiceThread->OnEventThreadRun()==false)
			{
				break;
			}
#endif
		}

		//停止通知
		try
		{ 
			pServiceThread->OnEventThreadConclude();
		} 
		catch (...)	{ ASSERT(FALSE); }
	}

	//中止线程
	_endthreadex(0L);

	return 0L;
}

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


#ifndef TIMERENGINE_HEAD_FILE
#define TIMERENGINE_HEAD_FILE

#pragma once

//系统头文件

#include "KernelEngineHead.h"
#include "QueueServiceEvent.h"

#define TIMER_SPACE								25				//时间间隔

//类说明
class CTimerEngine;

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

//定时器线程
class CTimerThread : public CWHThread
{
	//变量定义
protected:
	CTimerEngine						* m_pTimerEngine;				//定时器引擎
	//函数定义
public:
	//构造函数
	CTimerThread(void);
	//析构函数
	virtual ~CTimerThread(void);

	//功能函数
public:
	//配置函数
	bool InitThread(CTimerEngine * pTimerEngine);

	//重载函数
private:
	//运行函数
	virtual bool OnEventThreadRun();
};

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

//定时器子项
struct tagTimerItem
{
	DWORD								wTimerID;						//定时器 ID
	DWORD								dwElapse;						//定时时间
	DWORD								dwTimeLeave;					//倒计时间
	DWORD								dwRepeatTimes;					//重复次数
	WPARAM								wBindParam;						//绑定参数
};

//定时器子项数组定义
typedef CWHArray<tagTimerItem *> CTimerItemPtr;

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

//定时器引擎
class CTimerEngine : public ITimerEngine
{
	friend class CTimerThread;

	//状态变量
protected:
	bool								m_bService;						//运行标志
	CTimerItemPtr						m_TimerItemFree;				//空闲数组
	CTimerItemPtr						m_TimerItemActive;				//活动数组

	//组件变量
protected:
	CCriticalSection					m_CriticalSection;				//线程锁
	CTimerThread						m_TimerThread;					//定时器线程
	IQueueServiceSink *					m_pIQueueServiceSink;			//通知回调

	//函数定义
public:
	//构造函数
	CTimerEngine(void);
	//析构函数
	virtual ~CTimerEngine(void);

	//基础接口
public:
	//释放对象
	virtual VOID Release() { if (IsValid()) delete this; }
	//是否有效
	virtual bool IsValid() { return AfxIsValidAddress(this, sizeof(CTimerEngine)) ? true : false; }
	//接口查询
	virtual void * QueryInterface(const IID & Guid, DWORD dwQueryVer);

	//接口函数
public:
	//设置定时器
	virtual bool SetTimer(DWORD dwTimerID, DWORD dwElapse, DWORD dwRepeat, WPARAM dwBindParameter);
	//删除定时器
	virtual bool KillTimer(DWORD dwTimerID);
	//删除定时器
	virtual bool KillAllTimer();
	//设置接口
	virtual bool SetTimerEngineEvent(IUnknownEx * pIUnknownEx);

	//管理接口
public:
	//开始服务
	virtual bool StartService();
	//停止服务
	virtual bool ConcludeService();

	//内部函数
private:
	//定时器通知
	void OnTimerThreadSink();
};

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

#endif

#include "StdAfx.h"
#include "TimerEngine.h"
#include "TraceService.h" //

//宏定义
#define NO_TIME_LEFT						DWORD(-1)				//不响应时间

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

//构造函数
CTimerThread::CTimerThread(void)
{
	m_pTimerEngine = NULL;
}

//析构函数
CTimerThread::~CTimerThread(void)
{
}

//配置函数
bool CTimerThread::InitThread(CTimerEngine * pTimerEngine)
{
	if (pTimerEngine == NULL) return false;

	//设置变量
	m_pTimerEngine = pTimerEngine;

	return true;
}

//运行函数
bool CTimerThread::OnEventThreadRun()
{
	ASSERT(m_pTimerEngine != NULL);
	Sleep(TIMER_SPACE);
	m_pTimerEngine->OnTimerThreadSink();
	return true;
}

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

//构造函数
CTimerEngine::CTimerEngine(void)
{
	m_bService = false;
	m_pIQueueServiceSink = NULL;
}

//析构函数
CTimerEngine::~CTimerEngine(void)
{
	INT_PTR i = 0;
	//停止服务
	ConcludeService();

	//清理内存
	tagTimerItem * pTimerItem = NULL;
	for (i = 0; i < m_TimerItemFree.GetCount(); i++)
	{
		pTimerItem = m_TimerItemFree[i];
		ASSERT(pTimerItem != NULL);
		SafeDelete(pTimerItem);
	}
	for (i = 0; i < m_TimerItemActive.GetCount(); i++)
	{
		pTimerItem = m_TimerItemActive[i];
		ASSERT(pTimerItem != NULL);
		SafeDelete(pTimerItem);
	}
	m_TimerItemFree.RemoveAll();
	m_TimerItemActive.RemoveAll();

	return;
}

//接口查询
void * CTimerEngine::QueryInterface(const IID & Guid, DWORD dwQueryVer)
{
	QUERYINTERFACE(ITimerEngine, Guid, dwQueryVer);
	QUERYINTERFACE_IUNKNOWNEX(ITimerEngine, Guid, dwQueryVer);
	return NULL;
}

//设置定时器
bool CTimerEngine::SetTimer(DWORD dwTimerID, DWORD dwElapse, DWORD dwRepeat, WPARAM dwBindParameter)
{
	DEBUG_GUARD;

	//锁定资源
	CWHDataLocker lock(m_CriticalSection);//

	//效验参数
	ASSERT(dwRepeat > 0L);
	if (dwRepeat == 0) return false;

	//查找定时器
	bool bTimerExist = false;
	tagTimerItem * pTimerItem = NULL;
	for (INT_PTR i = 0; i < m_TimerItemActive.GetCount(); i++)
	{
		pTimerItem = m_TimerItemActive[i];
		ASSERT(pTimerItem != NULL);
		if (pTimerItem->wTimerID == dwTimerID)
		{
			bTimerExist = true;
			break;
		}
	}

	//创建定时器
	if (bTimerExist == false)
	{
		INT_PTR nFreeCount = m_TimerItemFree.GetCount();
		if (nFreeCount > 0)
		{
			pTimerItem = m_TimerItemFree[nFreeCount-1];
			ASSERT(pTimerItem != NULL);
			m_TimerItemFree.RemoveAt(nFreeCount - 1);
		}
		else
		{
			try
			{
				pTimerItem = new tagTimerItem;
				ASSERT(pTimerItem != NULL);
				if (pTimerItem == NULL) return false;
			}
			catch (...)
			{
				return false;
			}
		}
	}

	//设置参数
	ASSERT(pTimerItem != NULL);
	pTimerItem->wTimerID = dwTimerID;
	pTimerItem->wBindParam = dwBindParameter;
	pTimerItem->dwElapse = dwElapse;
	pTimerItem->dwRepeatTimes = dwRepeat;

	//提前20个粒度进行通知 - TIMER_SPACE * 20
	if (pTimerItem->dwRepeatTimes == 1)
		pTimerItem->dwTimeLeave = __max(TIMER_SPACE, pTimerItem->dwElapse - TIMER_SPACE * 20);
	else
		pTimerItem->dwTimeLeave = pTimerItem->dwElapse;

	//激活定时器
	if (bTimerExist == false)
		m_TimerItemActive.Add(pTimerItem);

	return true;
}

//删除定时器
bool CTimerEngine::KillTimer(DWORD dwTimerID)
{
	DEBUG_GUARD;

	//锁定资源
	CWHDataLocker lock(m_CriticalSection);//

	//查找定时器
	tagTimerItem * pTimerItem = NULL;
	for (INT_PTR i = 0; i < m_TimerItemActive.GetCount(); i++)
	{
		pTimerItem = m_TimerItemActive[i];
		ASSERT(pTimerItem != NULL);
		if (pTimerItem->wTimerID == dwTimerID)
		{
			m_TimerItemActive.RemoveAt(i);
			m_TimerItemFree.Add(pTimerItem);
			return true;;
		}
	}

	return false;
}

//删除定时器
bool CTimerEngine::KillAllTimer()
{
	//锁定资源
	CWHDataLocker lock(m_CriticalSection);//

	//删除定时器
	m_TimerItemFree.Append(m_TimerItemActive);
	m_TimerItemActive.RemoveAll();

	return true;
}

//开始服务
bool CTimerEngine::StartService()
{
	//效验状态
	if (m_bService == true)
	{
		CTraceService::TraceString(TEXT("定时器引擎重复启动，启动操作忽略"), TraceLevel_Warning);
		return true;
	}

	//设置变量
	if (m_TimerThread.InitThread(this) == false)
	{
		CTraceService::TraceString(TEXT("定时器引擎线程服务初始化失败"), TraceLevel_Exception);
		return false;
	}

	//启动服务
	if (m_TimerThread.StartThread() == false)
	{
		CTraceService::TraceString(TEXT("定时器引擎线程服务启动失败"), TraceLevel_Exception);
		return false;
	}

	SetThreadPriority(m_TimerThread.GetThreadHandle(), REALTIME_PRIORITY_CLASS);


	//设置变量
	m_bService = true;

	return true;
}

//停止服务
bool CTimerEngine::ConcludeService()
{
	//设置变量
	m_bService = false;

	//停止线程
	m_TimerThread.ConcludeThread(INFINITE);

	//设置变量
	m_TimerItemFree.Append(m_TimerItemActive);
	m_TimerItemActive.RemoveAll();

	return true;
}

//设置接口
bool CTimerEngine::SetTimerEngineEvent(IUnknownEx * pIUnknownEx)
{
	//效验参数
	ASSERT(pIUnknownEx != NULL);
	ASSERT(m_bService == false);
	if (m_bService == true) return false;
	if (pIUnknownEx == NULL) return false;

	//设置接口
	ASSERT(pIUnknownEx != NULL);
	m_pIQueueServiceSink = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, IQueueServiceSink);
	ASSERT(m_pIQueueServiceSink != NULL);
	return (m_pIQueueServiceSink != NULL);
}

//定时器通知
void CTimerEngine::OnTimerThreadSink()
{
	DEBUG_GUARD;

	//缓冲锁定
	CWHDataLocker lock(m_CriticalSection);//

	//查询定时器
	tagTimerItem * pTimerItem = NULL;
	for (INT_PTR i = m_TimerItemActive.GetCount() - 1; i >= 0; i--)
	{
		//效验参数
		pTimerItem = m_TimerItemActive[i];
		ASSERT(pTimerItem != NULL);
		if (pTimerItem == NULL) return;
		ASSERT(pTimerItem->dwTimeLeave > 0);
		
		//定时器处理
		bool bKillTimer = false;
		pTimerItem->dwTimeLeave -= TIMER_SPACE;
		if (pTimerItem->dwTimeLeave <= 0L)
		{
			//设置次数
			if (pTimerItem->dwRepeatTimes != TIMES_INFINITY)
			{
				ASSERT(pTimerItem->dwRepeatTimes > 0);
				pTimerItem->dwRepeatTimes--;
				if (pTimerItem->dwRepeatTimes == 0L)
				{
					bKillTimer = true;
					m_TimerItemActive.RemoveAt(i);
					m_TimerItemFree.Add(pTimerItem);
				}
			}

			//设置时间
			if (bKillTimer == false)//提前20个粒度进行通知 - TIMER_SPACE * 20
			{
				if (pTimerItem->dwRepeatTimes == 1)
					pTimerItem->dwTimeLeave = __max(TIMER_SPACE, pTimerItem->dwElapse - TIMER_SPACE * 20);
				else
					pTimerItem->dwTimeLeave = pTimerItem->dwElapse;
			}
	
			try
			{
				//BYTE cbBuffer[MAX_ASYNCHRONISM_DATA] = {0};		//接收缓冲//匿名
				BYTE cbBuffer[sizeof(NTY_TimerEvent)] = {0};  //接收缓冲
				//投递消息
				NTY_TimerEvent * pTimerEvent = (NTY_TimerEvent *)cbBuffer;
				pTimerEvent->dwTimerID = pTimerItem->wTimerID;
				pTimerEvent->dwBindParameter = pTimerItem->wBindParam;
				m_pIQueueServiceSink->OnQueueServiceSink(EVENT_TIMER, cbBuffer, sizeof(NTY_TimerEvent));
			}
			catch (...) { }
		}
	}
}

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

//建立对象函数
extern "C" __declspec(dllexport) void * CreateTimerEngine(const GUID & Guid, DWORD dwInterfaceVer)
{
	//建立对象
	CTimerEngine * pTimerEngine = NULL;
	try
	{
		pTimerEngine = new CTimerEngine();
		if (pTimerEngine == NULL) throw TEXT("创建失败");
		void * pObject = pTimerEngine->QueryInterface(Guid, dwInterfaceVer);
		if (pObject == NULL) throw TEXT("接口查询失败");
		return pObject;
	}
	catch (...) {}

	//清理对象
	SafeDelete(pTimerEngine);
	return NULL;
}

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

解读CWHThread类：
说是CWHThread类感觉它更像一个接口，要想使用此类必须重新写一个类继承它。重写OnEventThreadRun()函数，（OnEventThreadStrat和OnEventThreadConclude是可选重载），不明白IsRuning()和StartThread()和ConcludeThread三个函数为什么设为虚函数，感觉这三个函数没有重写的必要。线程函数设为私有的，这是因为类对象不可能调用该函数，此函数只共本类其他函数内部调用。由于线程函数要吗是全局函数，要吗是静态成员函数，本类就是一个线程，所以本类的线程函数是静态成员函数。这个静态成员函数有本类的StartThread成员函数调用。那么ThreadFunction去掉什么函数呢？让他掉用成员函数OnEventThreadRun，只要我们子类重新OnEventThreadRun函数就可以达到做任何业务的目的。那么问题就出来了，OnEventThreadRun函数是个静态成员函数，他如何调用本类的非静态成员函数呢，本代码提供了一种很好的机制，ThreadFunction函数加个参数，参数之一是指向CWHThread实例的类指针，通过这个指针再去调用成员函数，长见识了。


解读CWHThread类：


类互相缠绕的问题：
CWHThread的子类CTimerThread，专为CTimerEngine定制的子类，为什么这样说呢，因为类CTimerThread除了在CTimerEngine类里面有个实例外，此类不再会有其他实例。我们大眼一看，CTimerThread类里面包含了CTimerEngine类实例指针的属性，CTimerEngine里面包含了CTimerThread类的实例属性。这种开发方式采用了impl技术。（类CTimerEngine为了访问类CTimerThread的私有函数OnEventThreadRun把类CTimerThread添加为自己的友元类，再次不再赘述）。下面分析一下类互相缠绕的原因，类CTimerThread必须有个属性是CTimerEngine类的指针或者对象，因为只有这样它才会知道线程要干什么活（干活方式是用自己的成员函数OnEventThreadRun调用类CTimerEngine的成员函数）。接着是类CTimerEngine为什么会包含类CTimerThread的实例，用通俗的话来说就是类CTimerEngine会告诉类CTimerThread给谁在干活，以及什么时候开始干，具体到代码就是CTimerEngine类成员函数StartService调用m_TimerThread.InitThread(this)告诉类CTimerThread在给谁干活，m_TimerThread.StartThread()告诉类CTimerThread什么时候开始干。





版权声明：本文为博主原创文章，未经博主允许不得转载。

网狐定时器引擎分析

标签：

原文地址：http://blog.csdn.net/liujiayu2/article/details/46731429
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！