C++ 毫秒定时器

1. /*******************************************************************************
2. *LRTimer.h*
3. **
4. *WrittenbyMaxGurdziel2005underGNUGeneralPublicLicense*
5. *contactme:max[at]remoteSOS[dot]com*
6. **
7. *LRTimerisalowresolutiontimerclasswithowntimingthread.Itallows*
8. *anexternalcallbackfunctiontobesuppliedthatwillbecalledin*
9. *pre-definedtimeintervals.*
10. *Thesmallesttimerintervalyoucanuseis1ms.*
11. **
12. *Testedwithgccmingw&VisualC++6.0underWindowsXPHomeandPro*
13. **
14. **
15. *LRTimertimer;//defineLRTimerobject*
16. *timer.setInterval(100);//setintervalof100ms*
17. *timer.setCallbackProc(&myCallbackFunction,0);//setcallbackfunction*
18. *//it'sprototypeis:*
19. *//voidmyCallbackFunction(void*pParam);*
20. **
21. *timer.start();//startthetimer*
22. *....*
23. *timer.stop();//stopsthetimer*
24. *....*
25. *timer.start(200);//startstimerwithnewinterval*
26. **
27. **
28. *Examplecode:*
29. *CopyandpastebelowsamplecodetotestLRTimer*
30. **
31. ________________________________________________________________________________
33. #include<stdlib.h>
34. #include"LRTimer.h"
37. //definecallbackfunction
38. //
39. staticvoidmyCallback(void*data)
40. {
41. staticDWORDcnt=0;
42. charc;
43. cnt++;
44. switch(cnt%4)
45. {
46. case0:c='|';break;
47. case1:c='/';break;
48. case2:c='-';break;
49. case3:c='//';
50. }
51. printf("/b%c",c);
52. }
55. intmain(intargc,char*argv[])
56. {
57. LRTimerlrt;
58. lrt.setCallbackProc(&myCallback,NULL);//setthecallbackfunctionbyreference
59. lrt.setInterval(50);//setdelayintervalinmiliseconds
60. lrt.start();//startthetimer
61. getchar();//letitrunforawhile-pressEnter
62. lrt.stop();//stopthetimer
63. getchar();//waittoshowit'sstopped-Enter
64. lrt.start(200);//startwithdifferentdelay
65. getchar();
66. lrt.stop();
67. system("PAUSE");
68. return0;
69. }
71. ________________________________________________________________________________
72. **
73. *Permissiontouse,copy,modify,anddistributethissoftwareandits*
74. *documentationunderthetermsoftheGNUGeneralPublicLicenseishereby*
75. *granted.Norepresentationsaremadeaboutthesuitabilityofthissoftware*
76. *foranypurpose.Itisprovided"asis"withoutexpressorimpliedwarranty.*
77. *Seehttp://www.gnu.org/copyleft/gpl.htmlformoredetails.*
78. **
79. *AllIaskisthatifyouuseLRTimerinyourprojectretainthe*
80. *copyrightnotice.Ifyouhaveanycommentsandsuggestionspleaseemailme*
81. *max[at]remoteSOS[dot]com*
82. **
83. *******************************************************************************/
85. #ifndefLRTIMER_H__
86. #defineLRTIMER_H__
88. #ifndef_WIN32_WINNT
89. #define_WIN32_WINNT0x0500
90. #endif
92. //compilewith:/MT/D"_X86_"/c
93. //processor:x86
95. #include<windows.h>
96. #include<process.h>/*_beginthread,_endthread*/
97. #include<stdio.h>
98. #include<assert.h>
100. //defineasecondintermsof100ns-usedwithwaitabletimerAPI
101. #define_SECOND10000
103. typedefVOID(*LRTCallbackEventProc)(VOID*);
105. classLRTimer
106. {
107. public:
108. //defaultconstructorwith1secondinterval
109. LRTimer(DWORDdwInterval=1000);
111. //defaultdestructor
112. ~LRTimer();
114. //startstimerbycreatingnewthread.intervalmustbesetearlier
115. VOIDstart();
117. //startstimerwithgivenintervalinmiliseconds
118. VOIDstart(DWORD_interval_ms);
120. //stopsthetimer
121. VOIDstop();
123. //setstimeintervalinmiliseconds
124. VOIDsetInterval(DWORD_interval_ms);
126. //returnstimeintervalinms
127. DWORDgetInterval();
129. //setsfunctionthatwillbecalledontimeexpiration
130. VOIDsetCallbackProc(LRTCallbackEventProcpcbEventProc,VOID*pcbParam);
132. //returnstrueifLRtimeriscurrentlyrunning
133. BOOLisRunning();
135. //ItshouldbeusediftheworkerclasswilluseCRTfunctions
136. staticHANDLECrtCreateThread(LPSECURITY_ATTRIBUTESlpsa,DWORDdwStackSize,LPTHREAD_START_ROUTINEpfnThreadProc,void*pvParam,DWORDdwCreationFlags,DWORD*pdwThreadId)throw()
137. {
138. //sanitycheckforpdwThreadId
139. assert(sizeof(DWORD)==sizeof(unsignedint));
141. //_beginthreadexcallsCreateThreadwhichwillsetthelasterrorvaluebeforeitreturns
142. return(HANDLE)_beginthreadex(lpsa,dwStackSize,(unsignedint(__stdcall*)(void*))pfnThreadProc,pvParam,dwCreationFlags,(unsignedint*)pdwThreadId);
143. }
145. private:
146. DWORDm_dwInterval;//intervalbetweenalarms
148. LRTCallbackEventProcm_pCallback;//pointertousercallbackfunction
149. VOID*m_pcbParam;//pointertousercallbackparameter
151. BOOLm_bRunning;//timerrunningstate
152. HANDLEm_hTimerThread;//handletotimerthread
153. DWORDm_iID;//timerthreadid-addedforcompatibilitywithWin95/98
155. //timerclockingtreadruntine
156. virtualDWORDWINAPItimerThread();
158. //wrappertothreadruntinesoitcanbeusedwithinaclass
159. staticDWORDWINAPItimerThreadAdapter(PVOID_this)
160. {
161. return((LRTimer*)_this)->timerThread();
162. }
164. //timercallbackAPCprocedurecalledwhentimerissignaled
165. virtualVOIDCALLBACKTimerAPCProc(LPVOID,DWORD,DWORD);
167. //wrappertocallbackAPCproceduresoitcanbeusedwithinaclass
168. staticVOIDCALLBACKTimerAPCProcAdapter(PVOID_this,DWORDa1=0,DWORDa2=0)
169. {
170. ((LRTimer*)_this)->TimerAPCProc(NULL,a1,a2);
171. }
172. };
174. #endif

1. /*******************************************************************************
2. *LRTimer.cpp*
3. **
4. *WrittenbyMaxGurdziel2005underGNUGeneralPublicLicense*
5. *contactme:max[at]remoteSOS[dot]com*
6. **
7. *LRTimerisalowresolutiontimerclasswithowntimingthread.Itallows*
8. *anexternalcallbackfunctiontobesuppliedthatwillbecalledin*
9. *pre-definedtimeintervals.Thesmallesttimerintervalyoucanuseis1ms.*
10. **
11. *Seeheaderfileformoreinfo,usageinformationandexample*
12. **
13. **
14. **
15. *Permissiontouse,copy,modify,anddistributethissoftwareandits*
16. *documentationunderthetermsoftheGNUGeneralPublicLicenseishereby*
17. *granted.Norepresentationsaremadeaboutthesuitabilityofthissoftware*
18. *foranypurpose.Itisprovided"asis"withoutexpressorimpliedwarranty.*
19. *Seehttp://www.gnu.org/copyleft/gpl.htmlformoredetails.*
20. **
21. *AllIaskisthatifyouuseLRTimerinyourprojectyouretainthe*
22. *copyrightnotice.Ifyouhaveanycommentsandsuggestionspleaseemailme*
23. *max[at]remoteSOS[dot]com*
24. **
25. *2008-6-23ModifiedbyZhangLiang*
26. **
27. *******************************************************************************/
28. #include"stdafx.h"
30. #include"LRTimer.h"
32. #ifndef_WIN32_WINNT
33. #define_WIN32_WINNT0x0500
34. #endif
36. LRTimer::LRTimer(DWORDdwInterval):
37. m_dwInterval(dwInterval),
38. m_bRunning(FALSE),
39. m_pCallback(NULL),
40. m_pcbParam(NULL),
41. m_hTimerThread(0)
42. {}
44. LRTimer::~LRTimer()
45. {}
47. VOIDCALLBACKLRTimer::TimerAPCProc(LPVOID,DWORD,DWORD)
48. {
49. //callcustomcallbackfunction
50. if(NULL!=m_pCallback)
51. (*m_pCallback)(m_pcbParam);
53. #ifdef_DEBUG
54. else
55. printf("Nocallbackfunctionset/n");
56. #endif
57. }
59. DWORDWINAPILRTimer::timerThread()
60. {
61. HANDLEhTimer;
62. BOOLbSuccess;
63. LARGE_INTEGERliDueTime;
64. CHARszError[255];
66. CHARszTimerName[16];
67. sprintf_s(szTimerName,"LRT_%x",(DWORD)(DWORD_PTR)this);
69. if(hTimer=CreateWaitableTimerA(NULL,FALSE,szTimerName))
70. liDueTime.QuadPart=-(LONGLONG)m_dwInterval*_SECOND;
72. bSuccess=SetWaitableTimer(
73. hTimer,//Handletothetimerobject
74. &liDueTime,//Whentimerwillbecomesignaledfirsttime
75. m_dwInterval,//Periodictimerinterval
76. TimerAPCProcAdapter,//Completionroutine
77. this,//Argumenttothecompletionroutine
78. FALSE);//Donotrestoreasuspendedsystem
80. if(bSuccess){
81. while(m_bRunning)
82. SleepEx(1,TRUE);//SleepEx(0,TRUE)consumes100%CPUusage
83. CancelWaitableTimer(hTimer);
84. }else{
85. wsprintfA(szError,"SetWaitableTimerfailedwithError%d.",GetLastError());
86. #ifdef_DEBUG
87. MessageBoxA(NULL,szError,"Error",MB_ICONEXCLAMATION);
88. #endif
89. return1;
90. }
91. CloseHandle(hTimer);
92. return0;
93. }
96. VOIDLRTimer::start()
97. {
98. m_bRunning=TRUE;
100. if(m_hTimerThread!=0)
101. stop();
103. #ifndef_INC_CRTDEFS
104. m_hTimerThread=CreateThread(NULL,0,timerThreadAdapter,this,0,&m_iID);
105. #else
106. m_hTimerThread=CrtCreateThread(NULL,0,timerThreadAdapter,this,0,&m_iID);
107. #endif
109. if(m_hTimerThread==NULL)
110. {
111. #ifdef_DEBUG
112. printf("CreateThreadfailed(%d)/n",GetLastError());
113. #endif
114. return;
115. }
116. }
118. VOIDLRTimer::start(DWORD_interval_ms)
119. {
120. setInterval(_interval_ms);
121. start();
122. }
124. VOIDLRTimer::stop()
125. {
126. m_bRunning=FALSE;
127. CloseHandle(m_hTimerThread);
128. m_hTimerThread=0;
129. }
131. VOIDLRTimer::setInterval(DWORD_interval_ms)
132. {
133. m_dwInterval=_interval_ms;
134. }
136. DWORDLRTimer::getInterval()
137. {
138. returnm_dwInterval;
139. }
141. VOIDLRTimer::setCallbackProc(LRTCallbackEventProcpcbEventProc,VOID*pcbParam)
142. {
143. m_pCallback=pcbEventProc;
144. m_pcbParam=pcbParam;
145. }
147. BOOLLRTimer::isRunning()
148. {
149. returnm_bRunning;
150. }