Windows高精度时间

killerxf

　　目录
　　第1章计时    1
　　1.1 GetTickCount    1
　　1.2 timeGetTime    1
　　1.3 QueryPerformanceCounter    1
　　1.4 测试    2
　　第2章等待    4
　　2.1 Sleep    4
　　2.2 SetWaitableTimer    4
　　2.3 timeSetEvent    4
　　2.4 轮询    5
　　2.5 测试    6
　　第3章定时器    8
　　3.1 SetTimer    8
　　3.2 SetWaitableTimer    8
　　3.3 timeSetEvent    9
　　3.4 总结    9
　　第1章计时
　　计时就是获得两个时刻之间的时间。
　　1.1 GetTickCount
　　GetTickCount是很常用的函数。它获得Windows启动时刻到当前时刻的时间，单位为毫秒。关于它有两点需要说明：
　　1、它的实际精度只有15ms左右，具体请参考下文介绍的测试代码；
　　2、GetTickCount返回的是一个32位的无符号整数，Windows连续运行49.710天后，它将再次从零开始计时。
　　可使用GetTickCount64代替GetTickCount，它将返回一个64位的无符号整数。Windows连续运行5.8亿年后，其计时才会归零。
　　1.2 timeGetTime
　　timeGetTime的参数、返回值、作用与GetTickCount完全一致。只是它的精度比GetTickCount要高：大部分情况下能精确到1ms，有时它也只能精确到15ms。具体请参考下文介绍的测试代码。
　　1.3 QueryPerformanceCounter
　　Windows上可以使用高性能计时器，熟悉两个 API 函数即可。
　　QueryPerformanceCounter与GetTickCount类似，也是获得Windows启动时刻到当前时刻的时间，不过它的单位不是毫秒。它的单位需要通过QueryPerformanceFrequency来获得。QueryPerformanceFrequency将获得一个频率Freq，它表示高性能计时器1秒钟的计数次数，也就是说QueryPerformanceCounter获得的时间是一个计数值，其单位是 秒。
　　高性能计时器的精度：在笔者的电脑上，频率Freq为3134267，一个计数的时间是 秒，也就是0.319微秒或319纳秒。这也就是高性能计时器的精度。
　　高性能计时器的归零：QueryPerformanceCounter获得的计数是一个有符号的64位整数。频率Freq为3134267的Windows在连续运行9.3万年后，QueryPerformanceCounter获得的计数才可能归零。
　　需要注意：并不是所有的电脑都支持QueryPerformanceCounter。
　　1.4 测试
　　为了比较三个计时器的精度，特编制如下代码：

//使用高性能计时器实现的 GetTickCount 函数 　　double GetTickCountA() 　　{ 　　 __int64 Freq = 0; 　　 __int64 Count = 0; 　　 if(QueryPerformanceFrequency((LARGE_INTEGER*)&Freq) 　　 && Freq > 0 　　 && QueryPerformanceCounter((LARGE_INTEGER*)&Count)) 　　 { 　　 //乘以1000，把秒化为毫秒 　　 return (double)Count / (double)Freq * 1000.0; 　　 } 　　 return 0.0; 　　} 　　void Test() 　　{ 　　 timeBeginPeriod(1);        //提高timeGetTime的精度 　　 double        a0 = GetTickCountA(); 　　 DWORD    b0 = timeGetTime(); 　　 DWORD    c0 = GetTickCount(); 　　 Sleep(5); 　　 double        a1 = GetTickCountA(); 　　 DWORD    b1 = timeGetTime(); 　　 DWORD    c1 = GetTickCount(); 　　 timeEndPeriod(1);         //必须与timeBeginPeriod成对出现 　　 TRACE(_T("a=%.1lf\tb=%d\tc=%d\n"),a1-a0,b1-b0,c1-c0); 　　}

　　多次运行Test函数，可以得到如下结果：

a=5.0    b=5        c=15 　　a=4.9    b=5        c=0 　　a=1.4    b=15    c=16 　　a=4.2    b=5        c=0 　　a=4.9    b=5        c=0

　　如果认为高性能计时器最为可靠，就可以得到如下结论：
　　1、GetTickCount最不靠谱，其计时精度只有15ms左右；
　　2、timeGetTime大部分情况下比较靠谱，能够达到1ms的精度。但存在误差较大的情况；
　　3、Sleep(5)并不能准确的等待5ms。大部分情况下它会等待4.0~5.0ms，极个别的情况下会等待1.4ms、13.7ms。
　　第2章等待
　　2.1 Sleep
　　Sleep的用法很简单，如：Sleep(5)表示等待5ms。它最大的问题在于精度只有10ms左右。
　　2.2 SetWaitableTimer
　　使用SetWaitableTimer等待一段时间的示例代码如下：

void SleepA(double dMilliseconds) 　　{ 　　 HANDLE hTimer = CreateWaitableTimer(NULL,TRUE,NULL); 　　 if(hTimer) 　　 { 　　 __int64 nWait = -(__int64)(dMilliseconds * 10000.0); 　　 SetWaitableTimer(hTimer,(LARGE_INTEGER*)&nWait 　　 ,0,NULL,NULL,FALSE); 　　 WaitForSingleObject(hTimer,INFINITE); 　　 CloseHandle(hTimer); 　　 } 　　}

　　首先使用CreateWaitableTimer创建一个可等待定时器——hTimer，此时hTimer是无信号的。
　　调用SetWaitableTimer告诉系统何时设置hTimer为有信号。注意它的第二个参数nWait。nWait是一个64位的有符号整数，正数表示绝对时间，负数表示相对时间。nWait的单位是 秒，即100纳秒，dMilliseconds * 10000.0就是把毫秒转换为 秒，取负号表示相对时间，即调用SetWaitableTimer之后的时间。
　　WaitForSingleObject用来等待hTimer有信号时返回。
　　2.3 timeSetEvent
　　使用timeSetEvent等待一段时间的示例代码如下：

void SleepB(DWORD dwMilliseconds) 　　{ 　　 HANDLE hEvent = CreateEvent(NULL,FALSE,FALSE,NULL); 　　 timeSetEvent(dwMilliseconds,1,(LPTIMECALLBACK)hEvent 　　 ,0,TIME_ONESHOT | TIME_CALLBACK_EVENT_SET); 　　 WaitForSingleObject(hEvent,INFINITE); 　　 CloseHandle(hEvent); 　　}

　　CreateEvent创建了一个无信号的事件；
　　timeSetEvent告诉系统：dwMilliseconds毫秒后设置hEvent为有信号状态；timeSetEvent的第2个参数1表示精确到1毫秒；
　　WaitForSingleObject用来等待hEvent有信号时返回。
　　2.4 轮询
　　使用高性能计时器轮询的等待代码如下：

void SleepC(double dMilliseconds) 　　{ 　　 __int64 nFreq = 0; //频率 　　 __int64 nStart = 0; //起始计数 　　 if(QueryPerformanceCounter((LARGE_INTEGER*)&nStart) 　　 && QueryPerformanceFrequency((LARGE_INTEGER*)&nFreq) 　　 && nFreq > 0 　　 ) 　　 { 　　 __int64 nEnd = 0; //终止计数 　　 double k = 1000.0 / (double)nFreq; //将计数转换为毫秒 　　 for(;;) 　　 { 　　 QueryPerformanceCounter((LARGE_INTEGER*)&nEnd); 　　 if(dMilliseconds <= (double)(nEnd - nStart) * k) 　　 { 　　 break; 　　 } 　　 } 　　 } 　　}

　　2.5 测试
　　下面是测试代码

//使用高性能计时器实现的 GetTickCount 函数 　　double GetTickCountA() 　　{ 　　 __int64 Freq = 0; 　　 __int64 Count = 0; 　　 if(QueryPerformanceFrequency((LARGE_INTEGER*)&Freq) 　　 && Freq > 0 　　 && QueryPerformanceCounter((LARGE_INTEGER*)&Count)) 　　 {//乘以1000，把秒化为毫秒 　　 return (double)Count / (double)Freq * 1000.0; 　　 } 　　 return 0.0; 　　} 　　void Test() 　　{ 　　 {//Sleep 　　 double t0 = GetTickCountA(); 　　 Sleep(5); 　　 double t1 = GetTickCountA(); 　　 TRACE(_T("Sleep=%.3lf\t"),t1-t0); 　　 } 　　 {//A 　　 double t0 = GetTickCountA(); 　　 SleepA(5.678); 　　 double t1 = GetTickCountA(); 　　 TRACE(_T("A=%.3lf\t"),t1-t0); 　　 } 　　 {//B 　　 double t0 = GetTickCountA(); 　　 SleepB(5); 　　 double t1 = GetTickCountA(); 　　 TRACE(_T("B=%.3lf\t"),t1-t0); 　　 } 　　 {//C 　　 double t0 = GetTickCountA(); 　　 SleepC(5.678); 　　 double t1 = GetTickCountA(); 　　 TRACE(_T("C=%.3lf\n"),t1-t0); 　　 } 　　}

　　多次运行Test函数，可得到如下结果：

Sleep=3.768 A=5.770 B=49.875 C=5.679 　　Sleep=4.929 A=5.995 B=4.664 C=5.679 　　... ... ... 　　Sleep=4.778 A=12.760 B=9.730 C=5.679 　　... ... ... 　　Sleep=0.222 A=9.642 B=9.744 C=5.679 　　Sleep=5.269 A=9.639 B=9.815 C=5.679 　　Sleep=6.325 A=9.544 B=9.758 C=5.679 　　Sleep=8.554 A=9.623 B=9.749 C=5.679 　　Sleep=6.380 A=9.765 B=9.790 C=5.679 　　Sleep=7.488 A=9.579 B=9.806 C=5.679 　　Sleep=0.398 A=9.717 B=9.861 C=5.679 　　Sleep=8.791 A=9.871 B=9.860 C=5.679 　　Sleep=4.329 A=9.724 B=9.818 C=5.679 　　Sleep=5.549 A=9.783 B=9.823 C=5.678 　　Sleep=0.488 A=9.684 B=9.662 C=5.679 　　Sleep=5.488 A=9.530 B=9.807 C=5.679 　　Sleep=0.560 A=9.731 B=9.727 C=5.679 　　Sleep=7.604 A=9.631 B=9.738 C=5.679 　　Sleep=8.543 A=9.476 B=9.726 C=5.679 　　Sleep=3.548 A=9.786 B=9.879 C=5.679 　　Sleep=6.672 A=9.708 B=9.835 C=5.679 　　Sleep=1.586 A=9.545 B=9.779 C=5.679

　　结论：
　　1、最稳定、最靠谱、精度最高的是SleepC，即使用高性能计时器轮询等待。不过，它的CPU占用率最高；
　　2、Sleep、SleepA、SleepB都是不够稳定的。SleepA虽然能够设置到纳秒，但实际等待时间的精度连1毫秒都达不到。
　　第3章定时器
　　3.1 SetTimer
　　示例代码如下

VOID CALLBACK Timer(HWND hwnd,UINT uMsg 　　 ,UINT idEvent,DWORD dwTime) 　　{ 　　 TRACE(_T("Time=%.3lf\n"),GetTickCountA()); 　　} 　　void SetTimerAPI() 　　{ 　　 ::SetTimer(NULL,100,1,Timer); 　　}

　　调用函数SetTimerAPI，会发现SetTimer启动的定时器，最快10毫秒执行一次，有时会20毫秒执行一次。
　　3.2 SetWaitableTimer
　　示例代码如下

VOID CALLBACK TimerA(LPVOID lpArgToCompletionRoutine 　　 ,DWORD dwTimerLowValue,DWORD dwTimerHighValue) 　　{ 　　 TRACE(_T("TimeA=%.3lf\n"),GetTickCountA()); 　　} 　　void SetTimerA() 　　{ 　　 HANDLE hTimer = CreateWaitableTimer(NULL,FALSE,NULL); 　　 if(hTimer) 　　 { 　　 __int64 nWait = 0; 　　 SetWaitableTimer(hTimer,(LARGE_INTEGER*)&nWait 　　 ,1,TimerA,NULL,FALSE); 　　 for(int i = 0;i < 100;++i) 　　 { 　　 SleepEx(INFINITE,TRUE); 　　 } 　　 CloseHandle(hTimer); 　　 } 　　}

　　说明：SetWaitableTimer后，系统会定时把TimerA函数投递到SetWaitableTimer这行代码所在线程的APC（Asynchronous Procedure Calls）队列里。SleepEx的第2个参数为TRUE，表示一旦发现APC队列里有函数，就调用此函数，并把它从APC队列里删除，最后SleepEx会返回WAIT_IO_COMPLETION。所以，这里的SleepEx函数非常关键。
　　调用函数SetTimerA，会发现SetWaitableTimer启动的定时器，最快10毫秒执行一次，其执行周期比SetTimer稳定。
　　3.3 timeSetEvent
　　示例代码如下

void CALLBACK TimerB(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2) 　　{ 　　 TRACE(_T("TimeB=%.3lf\n"),GetTickCountA()); 　　} 　　void SetTimerB() 　　{ 　　 timeSetEvent(1,1,TimerB,0 　　 ,TIME_PERIODIC | TIME_CALLBACK_FUNCTION); 　　}

　　调用函数SetTimerB，会发现timeSetEvent启动的定时器，能够达到1毫秒执行一次，其执行周期前期非常不稳定大概0.1秒执行一次，过一段时间后就非常稳定了。
　　3.4 总结
　　1、最不靠谱的是SetTimer。它的实现原理是将WM_TIMER消息寄送至消息队列。因为消息队列里还有其它消息，它的处理时间不固定也就能够理解了；
　　2、SetWaitableTimer通过APC队列而不是消息队列实现了定时器。解决了定时器周期不稳定的问题，但是它的定时器周期最小也只能达到10毫秒；
　　3、timeSetEvent通过多线程实现了定时器（TimerB会被一个多线程调用）。使得定时器周期最小可达1毫秒。它最大的问题在于：前面一段时间（5毫秒）会以非常快的频率（0.1毫秒）调用定时处理函数。