网狐定时器引擎分析

先贴出来网狐源码：

[cpp]  view plain copy

1. #ifndef WH_THREAD_HEAD_FILE  
2. #define WH_THREAD_HEAD_FILE  
3.   
4. #pragma once  
5.   
6. #include "ServiceCoreHead.h"  
7.   
8. //  
9.   
10. //线程对象  
11. class SERVICE_CORE_CLASS CWHThread  
12. {  
13.     //状态变量  
14. private:  
15.     volatile bool                   m_bRun;                             //运行标志  
16.   
17.     //线程变量  
18. private:  
19.     UINT                            m_uThreadID;                        //线程标识  
20.     HANDLE                          m_hThreadHandle;                    //线程句柄  
21.   
22.     //函数定义  
23. protected:  
24.     //构造函数  
25.     CWHThread();  
26.     //析构函数  
27.     virtual ~CWHThread();  
28.   
29.     //接口函数  
30. public:  
31.     //获取状态  
32.     virtual bool IsRuning();  
33.     //启动线程  
34.     virtual bool StartThread();  
35.     //终止线程  
36.     virtual bool ConcludeThread(DWORD dwMillSeconds);  
37.   
38.     //功能函数  
39. public:  
40.     //线程标识  
41.     UINT GetThreadID() { return m_uThreadID; }  
42.     //线程句柄  
43.     HANDLE GetThreadHandle() { return m_hThreadHandle; }  
44.     //投递消息  
45.     LRESULT PostThreadMessage(UINT uMessage, WPARAM wParam, LPARAM lParam);  
46.   
47.     //事件函数  
48. protected:  
49.     //运行事件  
50.     virtual bool OnEventThreadRun() { return true; }  
51.     //开始事件  
52.     virtual bool OnEventThreadStrat() { return true; }  
53.     //终止事件  
54.     virtual bool OnEventThreadConclude() { return true; }  
55.   
56.     //内部函数  
57. private:  
58.     //线程函数  
59.     static unsigned __stdcall ThreadFunction(LPVOID pThreadData);  
60. };  
61.   
62. //  
63.   
64. #endif  

[cpp]  view plain copy

1. #include "StdAfx.h"  
2. #include "WHThread.h"  
3.   
4. //  
5. //结构定义  
6.   
7. //启动参数  
8. struct tagThreadParameter  
9. {  
10.     bool                            bSuccess;                           //是否错误  
11.     HANDLE                          hEventFinish;                       //事件句柄  
12.     CWHThread   *               pServiceThread;                     //线程指针  
13. };  
14.   
15. //  
16.   
17. //构造函数  
18. CWHThread::CWHThread()  
19. {  
20.     //设置变量  
21.     m_bRun=false;  
22.     m_uThreadID=0;  
23.     m_hThreadHandle=NULL;  
24.   
25.     return;  
26. }  
27.   
28. //析构函数  
29. CWHThread::~CWHThread()  
30. {  
31.     //停止线程  
32.     ConcludeThread(INFINITE);  
33.   
34.     return;  
35. }  
36.   
37. //状态判断  
38. bool CWHThread::IsRuning()  
39. {  
40.     //运行检测  
41.     if (m_hThreadHandle==NULL) return false;  
42.     if (WaitForSingleObject(m_hThreadHandle,0)!=WAIT_TIMEOUT) return false;  
43.   
44.     return true;  
45. }  
46.   
47. //启动线程  
48. bool CWHThread::StartThread()  
49. {  
50.     //效验状态  
51.     ASSERT(IsRuning()==false);  
52.     if (IsRuning()==true) return false;  
53.   
54.     //清理变量  
55.     if (m_hThreadHandle!=NULL)   
56.     {  
57.         //关闭句柄  
58.         CloseHandle(m_hThreadHandle);  
59.   
60.         //设置变量  
61.         m_uThreadID=0;  
62.         m_hThreadHandle=NULL;  
63.     }  
64.    
65.     //变量定义  
66.     tagThreadParameter ThreadParameter;  
67.     ZeroMemory(&ThreadParameter,sizeof(ThreadParameter));  
68.   
69.     //设置变量  
70.     ThreadParameter.bSuccess=false;  
71.     ThreadParameter.pServiceThread=this;  
72.     ThreadParameter.hEventFinish=CreateEvent(NULL,FALSE,FALSE,NULL);  
73.   
74.     //效验状态  
75.     ASSERT(ThreadParameter.hEventFinish!=NULL);  
76.     if (ThreadParameter.hEventFinish==NULL) return false;  
77.       
78.     //启动线程  
79.     m_bRun=true;  
80.     m_hThreadHandle=(HANDLE)::_beginthreadex(NULL,0,ThreadFunction,&ThreadParameter,0,&m_uThreadID);  
81.   
82.     //错误判断  
83.     if (m_hThreadHandle==INVALID_HANDLE_VALUE)  
84.     {  
85.         CloseHandle(ThreadParameter.hEventFinish);  
86.         return false;  
87.     }  
88.   
89.     //等待事件  
90.     WaitForSingleObject(ThreadParameter.hEventFinish,INFINITE);  
91.     CloseHandle(ThreadParameter.hEventFinish);  
92.   
93.     //判断错误  
94.     if (ThreadParameter.bSuccess==false)  
95.     {  
96.         ConcludeThread(INFINITE);  
97.         return false;  
98.     }  
99.   
100.     return true;  
101. }  
102.   
103. //停止线程  
104. bool CWHThread::ConcludeThread(DWORD dwMillSeconds)  
105. {  
106.     //停止线程  
107.     if (IsRuning()==true)  
108.     {  
109.         //设置变量  
110.         m_bRun=false;  
111.   
112.         //停止等待  
113.         if (WaitForSingleObject(m_hThreadHandle,dwMillSeconds)==WAIT_TIMEOUT)  
114.         {  
115.             return false;  
116.         }  
117.     }  
118.   
119.     //设置变量  
120.     if (m_hThreadHandle!=NULL)  
121.     {  
122.         //关闭句柄  
123.         CloseHandle(m_hThreadHandle);  
124.   
125.         //设置变量  
126.         m_uThreadID=0;  
127.         m_hThreadHandle=NULL;  
128.     }  
129.   
130.     return true;  
131. }  
132.   
133. //投递消息  
134. LRESULT CWHThread::PostThreadMessage(UINT uMessage, WPARAM wParam, LPARAM lParam)  
135. {  
136.     //状态效验  
137.     ASSERT((m_uThreadID!=0)&&(m_hThreadHandle!=NULL));  
138.     if ((m_uThreadID==0)||(m_hThreadHandle==NULL)) return false;  
139.   
140.     //投递消息  
141.     if (::PostThreadMessage(m_uThreadID,uMessage,wParam,lParam)==FALSE)  
142.     {  
143.         DWORD dwLastError=GetLastError();  
144.         return dwLastError;  
145.     }  
146.   
147.     return 0L;  
148. }  
149.   
150. //线程函数  
151. unsigned __stdcall CWHThread::ThreadFunction(LPVOID pThreadData)  
152. {  
153.     //随机种子  
154.     srand((DWORD)time(NULL));  
155.   
156.     //变量定义  
157.     tagThreadParameter * pThreadParameter=(tagThreadParameter *)pThreadData;  
158.     CWHThread * pServiceThread=pThreadParameter->pServiceThread;  
159.   
160.     //启动通知  
161.     try  
162.     {  
163.         pThreadParameter->bSuccess=pServiceThread->OnEventThreadStrat();   
164.     }   
165.     catch (...)  
166.     {  
167.         //设置变量  
168.         ASSERT(FALSE);  
169.         pThreadParameter->bSuccess=false;  
170.     }  
171.   
172.     //设置事件  
173.     bool bSuccess=pThreadParameter->bSuccess;  
174.     ASSERT(pThreadParameter->hEventFinish!=NULL);  
175.     if (pThreadParameter->hEventFinish!=NULL) SetEvent(pThreadParameter->hEventFinish);  
176.   
177.     //线程处理  
178.     if (bSuccess==true)  
179.     {  
180.         //线程运行  
181.         while (pServiceThread->m_bRun)  
182.         {  
183. #ifndef _DEBUG  
184.             //运行版本  
185.             try  
186.             {  
187.                 if (pServiceThread->OnEventThreadRun()==false)  
188.                 {  
189.                     break;  
190.                 }  
191.             }  
192.             catch (...) { }  
193. #else  
194.             //调试版本  
195.             if (pServiceThread->OnEventThreadRun()==false)  
196.             {  
197.                 break;  
198.             }  
199. #endif  
200.         }  
201.   
202.         //停止通知  
203.         try  
204.         {   
205.             pServiceThread->OnEventThreadConclude();  
206.         }   
207.         catch (...) { ASSERT(FALSE); }  
208.     }  
209.   
210.     //中止线程  
211.     _endthreadex(0L);  
212.   
213.     return 0L;  
214. }  
215.   
216. //  

[cpp]  view plain copy

1. #ifndef TIMERENGINE_HEAD_FILE  
2. #define TIMERENGINE_HEAD_FILE  
3.   
4. #pragma once  
5.   
6. //系统头文件  
7.   
8. #include "KernelEngineHead.h"  
9. #include "QueueServiceEvent.h"  
10.   
11. #define TIMER_SPACE                             25              //时间间隔  
12.   
13. //类说明  
14. class CTimerEngine;  
15.   
16. //  
17.   
18. //定时器线程  
19. class CTimerThread : public CWHThread  
20. {  
21.     //变量定义  
22. protected:  
23.     CTimerEngine                        * m_pTimerEngine;               //定时器引擎  
24.     //函数定义  
25. public:  
26.     //构造函数  
27.     CTimerThread(void);  
28.     //析构函数  
29.     virtual ~CTimerThread(void);  
30.   
31.     //功能函数  
32. public:  
33.     //配置函数  
34.     bool InitThread(CTimerEngine * pTimerEngine);  
35.   
36.     //重载函数  
37. private:  
38.     //运行函数  
39.     virtual bool OnEventThreadRun();  
40. };  
41.   
42. //  
43.   
44. //定时器子项  
45. struct tagTimerItem  
46. {  
47.     DWORD                               wTimerID;                       //定时器 ID  
48.     DWORD                               dwElapse;                       //定时时间  
49.     DWORD                               dwTimeLeave;                    //倒计时间  
50.     DWORD                               dwRepeatTimes;                  //重复次数  
51.     WPARAM                              wBindParam;                     //绑定参数  
52. };  
53.   
54. //定时器子项数组定义  
55. typedef CWHArray<tagTimerItem *> CTimerItemPtr;  
56.   
57. //  
58.   
59. //定时器引擎  
60. class CTimerEngine : public ITimerEngine  
61. {  
62.     friend class CTimerThread;  
63.   
64.     //状态变量  
65. protected:  
66.     bool                                m_bService;                     //运行标志  
67.     CTimerItemPtr                       m_TimerItemFree;                //空闲数组  
68.     CTimerItemPtr                       m_TimerItemActive;              //活动数组  
69.   
70.     //组件变量  
71. protected:  
72.     CCriticalSection                    m_CriticalSection;              //线程锁  
73.     CTimerThread                        m_TimerThread;                  //定时器线程  
74.     IQueueServiceSink *                 m_pIQueueServiceSink;           //通知回调  
75.   
76.     //函数定义  
77. public:  
78.     //构造函数  
79.     CTimerEngine(void);  
80.     //析构函数  
81.     virtual ~CTimerEngine(void);  
82.   
83.     //基础接口  
84. public:  
85.     //释放对象  
86.     virtual VOID Release() { if (IsValid()) delete this; }  
87.     //是否有效  
88.     virtual bool IsValid() { return AfxIsValidAddress(this, sizeof(CTimerEngine)) ? true : false; }  
89.     //接口查询  
90.     virtual void * QueryInterface(const IID & Guid, DWORD dwQueryVer);  
91.   
92.     //接口函数  
93. public:  
94.     //设置定时器  
95.     virtual bool SetTimer(DWORD dwTimerID, DWORD dwElapse, DWORD dwRepeat, WPARAM dwBindParameter);  
96.     //删除定时器  
97.     virtual bool KillTimer(DWORD dwTimerID);  
98.     //删除定时器  
99.     virtual bool KillAllTimer();  
100.     //设置接口  
101.     virtual bool SetTimerEngineEvent(IUnknownEx * pIUnknownEx);  
102.   
103.     //管理接口  
104. public:  
105.     //开始服务  
106.     virtual bool StartService();  
107.     //停止服务  
108.     virtual bool ConcludeService();  
109.   
110.     //内部函数  
111. private:  
112.     //定时器通知  
113.     void OnTimerThreadSink();  
114. };  
115.   
116. //  
117.   
118. #endif  

[cpp]  view plain copy

1. #include "StdAfx.h"  
2. #include "TimerEngine.h"  
3. #include "TraceService.h" //  
4.   
5. //宏定义  
6. #define NO_TIME_LEFT                        DWORD(-1)               //不响应时间  
7.   
8. //  
9.   
10. //构造函数  
11. CTimerThread::CTimerThread(void)  
12. {  
13.     m_pTimerEngine = NULL;  
14. }  
15.   
16. //析构函数  
17. CTimerThread::~CTimerThread(void)  
18. {  
19. }  
20.   
21. //配置函数  
22. bool CTimerThread::InitThread(CTimerEngine * pTimerEngine)  
23. {  
24.     if (pTimerEngine == NULL) return false;  
25.   
26.     //设置变量  
27.     m_pTimerEngine = pTimerEngine;  
28.   
29.     return true;  
30. }  
31.   
32. //运行函数  
33. bool CTimerThread::OnEventThreadRun()  
34. {  
35.     ASSERT(m_pTimerEngine != NULL);  
36.     Sleep(TIMER_SPACE);  
37.     m_pTimerEngine->OnTimerThreadSink();  
38.     return true;  
39. }  
40.   
41. //  
42.   
43. //构造函数  
44. CTimerEngine::CTimerEngine(void)  
45. {  
46.     m_bService = false;  
47.     m_pIQueueServiceSink = NULL;  
48. }  
49.   
50. //析构函数  
51. CTimerEngine::~CTimerEngine(void)  
52. {  
53.     INT_PTR i = 0;  
54.     //停止服务  
55.     ConcludeService();  
56.   
57.     //清理内存  
58.     tagTimerItem * pTimerItem = NULL;  
59.     for (i = 0; i < m_TimerItemFree.GetCount(); i++)  
60.     {  
61.         pTimerItem = m_TimerItemFree[i];  
62.         ASSERT(pTimerItem != NULL);  
63.         SafeDelete(pTimerItem);  
64.     }  
65.     for (i = 0; i < m_TimerItemActive.GetCount(); i++)  
66.     {  
67.         pTimerItem = m_TimerItemActive[i];  
68.         ASSERT(pTimerItem != NULL);  
69.         SafeDelete(pTimerItem);  
70.     }  
71.     m_TimerItemFree.RemoveAll();  
72.     m_TimerItemActive.RemoveAll();  
73.   
74.     return;  
75. }  
76.   
77. //接口查询  
78. void * CTimerEngine::QueryInterface(const IID & Guid, DWORD dwQueryVer)  
79. {  
80.     QUERYINTERFACE(ITimerEngine, Guid, dwQueryVer);  
81.     QUERYINTERFACE_IUNKNOWNEX(ITimerEngine, Guid, dwQueryVer);  
82.     return NULL;  
83. }  
84.   
85. //设置定时器  
86. bool CTimerEngine::SetTimer(DWORD dwTimerID, DWORD dwElapse, DWORD dwRepeat, WPARAM dwBindParameter)  
87. {  
88.     DEBUG_GUARD;  
89.   
90.     //锁定资源  
91.     CWHDataLocker lock(m_CriticalSection);//  
92.   
93.     //效验参数  
94.     ASSERT(dwRepeat > 0L);  
95.     if (dwRepeat == 0) return false;  
96.   
97.     //查找定时器  
98.     bool bTimerExist = false;  
99.     tagTimerItem * pTimerItem = NULL;  
100.     for (INT_PTR i = 0; i < m_TimerItemActive.GetCount(); i++)  
101.     {  
102.         pTimerItem = m_TimerItemActive[i];  
103.         ASSERT(pTimerItem != NULL);  
104.         if (pTimerItem->wTimerID == dwTimerID)  
105.         {  
106.             bTimerExist = true;  
107.             break;  
108.         }  
109.     }  
110.   
111.     //创建定时器  
112.     if (bTimerExist == false)  
113.     {  
114.         INT_PTR nFreeCount = m_TimerItemFree.GetCount();  
115.         if (nFreeCount > 0)  
116.         {  
117.             pTimerItem = m_TimerItemFree[nFreeCount-1];  
118.             ASSERT(pTimerItem != NULL);  
119.             m_TimerItemFree.RemoveAt(nFreeCount - 1);  
120.         }  
121.         else  
122.         {  
123.             try  
124.             {  
125.                 pTimerItem = new tagTimerItem;  
126.                 ASSERT(pTimerItem != NULL);  
127.                 if (pTimerItem == NULL) return false;  
128.             }  
129.             catch (...)  
130.             {  
131.                 return false;  
132.             }  
133.         }  
134.     }  
135.   
136.     //设置参数  
137.     ASSERT(pTimerItem != NULL);  
138.     pTimerItem->wTimerID = dwTimerID;  
139.     pTimerItem->wBindParam = dwBindParameter;  
140.     pTimerItem->dwElapse = dwElapse;  
141.     pTimerItem->dwRepeatTimes = dwRepeat;  
142.   
143.     //提前20个粒度进行通知 - TIMER_SPACE * 20  
144.     if (pTimerItem->dwRepeatTimes == 1)  
145.         pTimerItem->dwTimeLeave = __max(TIMER_SPACE, pTimerItem->dwElapse - TIMER_SPACE * 20);  
146.     else  
147.         pTimerItem->dwTimeLeave = pTimerItem->dwElapse;  
148.   
149.     //激活定时器  
150.     if (bTimerExist == false)  
151.         m_TimerItemActive.Add(pTimerItem);  
152.   
153.     return true;  
154. }  
155.   
156. //删除定时器  
157. bool CTimerEngine::KillTimer(DWORD dwTimerID)  
158. {  
159.     DEBUG_GUARD;  
160.   
161.     //锁定资源  
162.     CWHDataLocker lock(m_CriticalSection);//  
163.   
164.     //查找定时器  
165.     tagTimerItem * pTimerItem = NULL;  
166.     for (INT_PTR i = 0; i < m_TimerItemActive.GetCount(); i++)  
167.     {  
168.         pTimerItem = m_TimerItemActive[i];  
169.         ASSERT(pTimerItem != NULL);  
170.         if (pTimerItem->wTimerID == dwTimerID)  
171.         {  
172.             m_TimerItemActive.RemoveAt(i);  
173.             m_TimerItemFree.Add(pTimerItem);  
174.             return true;;  
175.         }  
176.     }  
177.   
178.     return false;  
179. }  
180.   
181. //删除定时器  
182. bool CTimerEngine::KillAllTimer()  
183. {  
184.     //锁定资源  
185.     CWHDataLocker lock(m_CriticalSection);//  
186.   
187.     //删除定时器  
188.     m_TimerItemFree.Append(m_TimerItemActive);  
189.     m_TimerItemActive.RemoveAll();  
190.   
191.     return true;  
192. }  
193.   
194. //开始服务  
195. bool CTimerEngine::StartService()  
196. {  
197.     //效验状态  
198.     if (m_bService == true)  
199.     {  
200.         CTraceService::TraceString(TEXT("定时器引擎重复启动，启动操作忽略"), TraceLevel_Warning);  
201.         return true;  
202.     }  
203.   
204.     //设置变量  
205.     if (m_TimerThread.InitThread(this) == false)  
206.     {  
207.         CTraceService::TraceString(TEXT("定时器引擎线程服务初始化失败"), TraceLevel_Exception);  
208.         return false;  
209.     }  
210.   
211.     //启动服务  
212.     if (m_TimerThread.StartThread() == false)  
213.     {  
214.         CTraceService::TraceString(TEXT("定时器引擎线程服务启动失败"), TraceLevel_Exception);  
215.         return false;  
216.     }  
217.   
218.     SetThreadPriority(m_TimerThread.GetThreadHandle(), REALTIME_PRIORITY_CLASS);  
219.   
220.   
221.     //设置变量  
222.     m_bService = true;  
223.   
224.     return true;  
225. }  
226.   
227. //停止服务  
228. bool CTimerEngine::ConcludeService()  
229. {  
230.     //设置变量  
231.     m_bService = false;  
232.   
233.     //停止线程  
234.     m_TimerThread.ConcludeThread(INFINITE);  
235.   
236.     //设置变量  
237.     m_TimerItemFree.Append(m_TimerItemActive);  
238.     m_TimerItemActive.RemoveAll();  
239.   
240.     return true;  
241. }  
242.   
243. //设置接口  
244. bool CTimerEngine::SetTimerEngineEvent(IUnknownEx * pIUnknownEx)  
245. {  
246.     //效验参数  
247.     ASSERT(pIUnknownEx != NULL);  
248.     ASSERT(m_bService == false);  
249.     if (m_bService == true) return false;  
250.     if (pIUnknownEx == NULL) return false;  
251.   
252.     //设置接口  
253.     ASSERT(pIUnknownEx != NULL);  
254.     m_pIQueueServiceSink = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, IQueueServiceSink);  
255.     ASSERT(m_pIQueueServiceSink != NULL);  
256.     return (m_pIQueueServiceSink != NULL);  
257. }  
258.   
259. //定时器通知  
260. void CTimerEngine::OnTimerThreadSink()  
261. {  
262.     DEBUG_GUARD;  
263.   
264.     //缓冲锁定  
265.     CWHDataLocker lock(m_CriticalSection);//  
266.   
267.     //查询定时器  
268.     tagTimerItem * pTimerItem = NULL;  
269.     for (INT_PTR i = m_TimerItemActive.GetCount() - 1; i >= 0; i--)  
270.     {  
271.         //效验参数  
272.         pTimerItem = m_TimerItemActive[i];  
273.         ASSERT(pTimerItem != NULL);  
274.         if (pTimerItem == NULL) return;  
275.         ASSERT(pTimerItem->dwTimeLeave > 0);  
276.           
277.         //定时器处理  
278.         bool bKillTimer = false;  
279.         pTimerItem->dwTimeLeave -= TIMER_SPACE;  
280.         if (pTimerItem->dwTimeLeave <= 0L)  
281.         {  
282.             //设置次数  
283.             if (pTimerItem->dwRepeatTimes != TIMES_INFINITY)  
284.             {  
285.                 ASSERT(pTimerItem->dwRepeatTimes > 0);  
286.                 pTimerItem->dwRepeatTimes--;  
287.                 if (pTimerItem->dwRepeatTimes == 0L)  
288.                 {  
289.                     bKillTimer = true;  
290.                     m_TimerItemActive.RemoveAt(i);  
291.                     m_TimerItemFree.Add(pTimerItem);  
292.                 }  
293.             }  
294.   
295.             //设置时间  
296.             if (bKillTimer == false)//提前20个粒度进行通知 - TIMER_SPACE * 20  
297.             {  
298.                 if (pTimerItem->dwRepeatTimes == 1)  
299.                     pTimerItem->dwTimeLeave = __max(TIMER_SPACE, pTimerItem->dwElapse - TIMER_SPACE * 20);  
300.                 else  
301.                     pTimerItem->dwTimeLeave = pTimerItem->dwElapse;  
302.             }  
303.       
304.             try  
305.             {  
306.                 //BYTE cbBuffer[MAX_ASYNCHRONISM_DATA] = {0};       //接收缓冲//匿名  
307.                 BYTE cbBuffer[sizeof(NTY_TimerEvent)] = {0};  //接收缓冲  
308.                 //投递消息  
309.                 NTY_TimerEvent * pTimerEvent = (NTY_TimerEvent *)cbBuffer;  
310.                 pTimerEvent->dwTimerID = pTimerItem->wTimerID;  
311.                 pTimerEvent->dwBindParameter = pTimerItem->wBindParam;  
312.                 m_pIQueueServiceSink->OnQueueServiceSink(EVENT_TIMER, cbBuffer, sizeof(NTY_TimerEvent));  
313.             }  
314.             catch (...) { }  
315.         }  
316.     }  
317. }  
318.   
319. //  
320.   
321. //建立对象函数  
322. extern "C" __declspec(dllexport) void * CreateTimerEngine(const GUID & Guid, DWORD dwInterfaceVer)  
323. {  
324.     //建立对象  
325.     CTimerEngine * pTimerEngine = NULL;  
326.     try  
327.     {  
328.         pTimerEngine = new CTimerEngine();  
329.         if (pTimerEngine == NULL) throw TEXT("创建失败");  
330.         void * pObject = pTimerEngine->QueryInterface(Guid, dwInterfaceVer);  
331.         if (pObject == NULL) throw TEXT("接口查询失败");  
332.         return pObject;  
333.     }  
334.     catch (...) {}  
335.   
336.     //清理对象  
337.     SafeDelete(pTimerEngine);  
338.     return NULL;  
339. }  
340.   
341. //  

解读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