用线程实现的计时器

#ifndef THREADTIMER_H
#define THREADTIMER_H

template <class TYPE> class CThreadTimer : CObject
{
public:
	typedef void (TYPE::*FN_TIMEOUT)();
public:
	DWORD GetInterval() const { return m_dwInterval; }

	void SetInterval(DWORD dwInterval)
	{
		m_dwInterval = dwInterval;
		m_evtObjects[0].SetEvent();
	}

	BOOL GetEnabled() const { return m_bEnabled; }

	void SetEnabled(BOOL bEnabled)
	{
		m_bEnabled = bEnabled;		
		m_evtObjects[0].SetEvent();
	}

	CThreadTimer(TYPE* pTimeout, FN_TIMEOUT fnTimeout)
		: m_dwInterval(1000), m_bEnabled(FALSE)
	{
		m_pTimeout = pTimeout;
		m_fnTimeout = fnTimeout;
		m_hThread = CreateThread(NULL, 0, ThreadProc, this, 0, NULL);
	}

	~CThreadTimer()
	{
		if (m_hThread)
		{
			m_evtObjects[1].SetEvent();
			if (WaitForSingleObject(m_hThread, 5000) != WAIT_TIMEOUT)
			{
				TerminateThread(m_hThread, WAIT_ABANDONED);
			}
			CloseHandle(m_hThread);
			m_hThread = NULL;
		}
	}
private:
	DWORD ThreadProc()
	{
		DWORD dwInterval = 0;
		CSyncObject* ppObjects[2];
		ppObjects[0] = &m_evtObjects[0];
		ppObjects[1] = &m_evtObjects[1];
		DWORD dwCount = sizeof(m_evtObjects) / sizeof(m_evtObjects[0]);
		for ( ; ; )
		{
			dwInterval = m_bEnabled ? m_dwInterval : INFINITE;

			CMultiLock lock(ppObjects, dwCount);
			DWORD dwWait = lock.Lock(dwInterval, FALSE);
			if (dwWait == WAIT_OBJECT_0 + 1) break;
			if (dwWait == WAIT_TIMEOUT)
			{
				if (m_pTimeout && m_fnTimeout) (m_pTimeout->*m_fnTimeout)();
			}
		}
		return 0;
	}

	static DWORD ThreadProc(LPVOID lpParam)
	{
		return ((CThreadTimer*) lpParam)->ThreadProc();
	}
private:
	TYPE* m_pTimeout;

	FN_TIMEOUT m_fnTimeout;

	DWORD m_dwInterval;

	BOOL m_bEnabled;

	HANDLE m_hThread;

	CEvent m_evtObjects[2];
};

#endif // THREADTIMER_H