Windows下的高精度定时器实现及精确时刻获取

通讯、VOIP、视频等领域的很多核心技术对时间精度的要求非常高，比如数据采集、时间同步、媒体流平滑控制、拥塞算法等等，很多技术都是以毫秒为单位来进行计算和控制的。但是Windows设计之初并不是以实时系统为目标的，所以Windows系统的时间精度一直不高，实际最小单位是15ms左右，导致的结果就是所有Windows的时间、线程相关的操作都无法以1ms来实现精确控制。

受影响的操作包括Sleep、GetTickCount、_ftime等等。比如你调用Sleep(2)，期待2ms之后线程自动唤醒，但是实际结果可能是15ms甚至2x ms的时候才会唤醒，对于简单应用来说影响不大，但是对于精度要求非常高的系统来说，这样的问题就是非常致命的了。

代码思路如下：

1、高精度定时器。使用Singleton模式挂起请求Sleep的线程并统一管理，后台使用Windows MultiMedia SDK的定期回调函数不断检测并回复到时的线程，超时时间与当前时间采用QueryPerformanceCounter/QueryPerformanceFrequency的高精度计时，确保整体功能可靠性。

2、精确时刻获取。由于可以获取到毫秒级别的_ftime与GetTickCount都受到Windows系统时间精度影响，最小单位只有15ms，所以需要借助QueryPerformanceCounter/QueryPerformanceFrequency进行准确计时。代码首先根据_ftime获取起始时刻的精确刻度，然后根据差量计算当前的精确时刻。

代码中的Singleton模式可以找到很多实现，因此本文不进行详述

代码（VS2005 c++编译）

1、高精度定时器

[c-sharp]
view plaincopy

#pragma once

#include <Windows.h>
#include <list>
#include <akumaslab/system/singleton.hpp>

namespace akumaslab{
namespace time{
using std::list;

class PreciseTimerProvider
{
struct WaitedHandle{
HANDLE threadHandle;
LONGLONG elapsed;//超时时间
} ;
typedef list< WaitedHandle > handle_list_type;
typedef akumaslab::system::Singleton< PreciseTimerProvider > timer_type;
public:
PreciseTimerProvider(void):highResolutionAvailable(false), timerID(0)
{
InitializeCriticalSection(&critical);
static LARGE_INTEGER systemFrequency;
if(0 != QueryPerformanceFrequency(&systemFrequency))
{
timeBeginPeriod(callbackInterval);
highResolutionAvailable = true;
countPerMilliSecond = systemFrequency.QuadPart/1000;
timerID = timeSetEvent(callbackInterval, 0, &PreciseTimerProvider::TimerFunc, NULL, TIME_PERIODIC);
}
}
//挂起当前线程
//@milliSecond:超时时间，单位：毫秒
bool suspendCurrentThread(int milliSecond)
{
if(milliSecond <= 0)return false;
if (!highResolutionAvailable)return false;
HANDLE currentThreadHandle = GetCurrentThread();
HANDLE currentProcessHandle = GetCurrentProcess();
HANDLE realThreadHandle(0);
DuplicateHandle(currentProcessHandle, currentThreadHandle, currentProcessHandle, &realThreadHandle, 0, FALSE, DUPLICATE_SAME_ACCESS);
WaitedHandle item;
item.threadHandle = realThreadHandle;
LARGE_INTEGER now;
QueryPerformanceCounter(&now);
now.QuadPart += milliSecond * countPerMilliSecond;
item.elapsed = now.QuadPart;
EnterCriticalSection(&critical);
waitList.push_back(item);
LeaveCriticalSection(&critical);
//挂起线程
SuspendThread(realThreadHandle);
CloseHandle(realThreadHandle);
return true;
}
//恢复超时线程
void resumeTimeoutThread()
{
if (!highResolutionAvailable)return;
LARGE_INTEGER now;
QueryPerformanceCounter(&now);
EnterCriticalSection(&critical);
for (handle_list_type::iterator ir = waitList.begin(); ir != waitList.end(); )
{
WaitedHandle& waited = *ir;
if (now.QuadPart >= waited.elapsed)
{
ResumeThread(waited.threadHandle);
ir = waitList.erase(ir);
continue;
}
ir++;
}
LeaveCriticalSection(&critical);
}
~PreciseTimerProvider(){
if (0 != timerID)
{
timeKillEvent(timerID);
timerID = 0;
timeEndPeriod(callbackInterval);
}
DeleteCriticalSection(&critical);
}
private:

static void CALLBACK TimerFunc(UINT uID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
{
static bool initialed = false;
if (!initialed)
{
if (initialWorkThread())
{
initialed = true;
}
else{
return;
}
}
timer_type::getRef().resumeTimeoutThread();
}
//调整定时器工作线程优先级
static bool initialWorkThread()
{
HANDLE realProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, _getpid());
if (NULL == realProcessHandle)
{
return false;
}
if (0 == SetPriorityClass(realProcessHandle, REALTIME_PRIORITY_CLASS))
{
CloseHandle(realProcessHandle);
return false;
}
HANDLE currentThreadHandle = GetCurrentThread();
HANDLE currentProcessHandle = GetCurrentProcess();
HANDLE realThreadHandle(0);
DuplicateHandle(currentProcessHandle, currentThreadHandle, currentProcessHandle, &realThreadHandle, 0, FALSE, DUPLICATE_SAME_ACCESS);
SetThreadPriority(realThreadHandle, THREAD_PRIORITY_TIME_CRITICAL);
//必须关闭复制句柄
CloseHandle(realThreadHandle);
CloseHandle(realProcessHandle);
return true;
}
private:
const static int callbackInterval = 1;
CRITICAL_SECTION critical;
MMRESULT timerID;
LONGLONG countPerMilliSecond;
bool highResolutionAvailable;
handle_list_type waitList;
};
class PreciseTimer
{
typedef akumaslab::system::Singleton< PreciseTimerProvider > timer_type;
public:
static bool wait(int milliSecond)
{
//static PreciseTimerProvider timer;
return timer_type::getRef().suspendCurrentThread(milliSecond);
}
};
}
}

DEMO

[cpp]
view plaincopy

int interval = 1;
int repeatCount = 50;
cout << getCurrentTime() << "test begin" << endl;
unit.reset();
for (int i = 0; i < repeatCount; i++)
{
akumaslab::time::PreciseTimer::wait(interval);
cout << getCurrentTime() << "/" << getNewTime() << " used " << unit.getPreciseElapsedTime() << " ms" << endl;
unit.reset();
}

2、精确时刻获取

[cpp]
view plaincopy

#pragma once

#include <sys/timeb.h>
#include <time.h>
#include <Windows.h>
#include <akumaslab/system/singleton.hpp>

namespace akumaslab{
namespace time{
struct HighResolutionTime
{
int year;
int month;
int day;
int hour;
int min;
int second;
int millisecond;
};
class CurrentTimeProvider
{
public:
CurrentTimeProvider():highResolutionAvailable(false), countPerMilliSecond(0), beginCount(0)
{
static LARGE_INTEGER systemFrequency;
if(0 != QueryPerformanceFrequency(&systemFrequency))
{
highResolutionAvailable = true;
countPerMilliSecond = systemFrequency.QuadPart/1000;
_timeb tb;
_ftime_s(&tb);
unsigned short currentMilli = tb.millitm;
LARGE_INTEGER now;
QueryPerformanceCounter(&now);
beginCount = now.QuadPart - (currentMilli*countPerMilliSecond);
}
};
bool getCurrentTime(HighResolutionTime& _time)
{
time_t tt;
::time(&tt);
tm now;
localtime_s(&now, &tt);
_time.year = now.tm_year + 1900;
_time.month = now.tm_mon + 1;
_time.day = now.tm_mday + 1;
_time.hour = now.tm_hour;
_time.min = now.tm_min;
_time.second = now.tm_sec;
if (!highResolutionAvailable)
{
_time.millisecond = 0;
}
else{
LARGE_INTEGER qfc;
QueryPerformanceCounter(&qfc);
_time.millisecond = (int)((qfc.QuadPart - beginCount)/countPerMilliSecond)%1000;
}
return true;
}
private:
bool highResolutionAvailable;
LONGLONG countPerMilliSecond;
LONGLONG beginCount;
};
class CurrentTime
{
public:
static bool get(HighResolutionTime& _time)
{
return akumaslab::system::Singleton< CurrentTimeProvider >::getRef().getCurrentTime(_time);
}
};
}
}

DEMO：

[cpp]
view plaincopy

HighResolutionTime time;
CurrentTime::get(time);
const int size = 20;
char buf[size] = {0};
_snprintf_s(buf, size, size, "%02d:%02d %02d:%02d:%02d.%03d ", time.month, time.day, time.hour, time.min, time.second, time.millisecond);

测试结果如下，下图是高精度计时器按1ms进行Sleep的结果，左侧为使用_ftime计时，右侧为使用精确时刻计时，总体来说，虽然无法达到100%可靠，但是相对原来的15ms已经有较大提升，期望Windows能够尽快提供真正的高精度时间管理技术