前段时间一个项目需要用到1/24s的高精度定时器，每秒的误差不能超过10ms，大约41.666666666毫秒的延时，普通Sleep肯定是没办法满足的了，可以用以下新的三种方法：
/*
// 1秒=1000毫秒(ms)
// 1毫秒=1/1000秒(s)
// 1秒=1000000 微秒(μs)
// 1微秒=1/1000000秒(s)
// 1秒=1000000000 纳秒(ns)
// 1纳秒=1/1000000000秒(s)
// lTime----休眠时间（微秒）
*/1、利用CreateWaitableTimer实现纳秒级延时
/*
纳秒休眠，符号ns（英语：nanosecond ）.
1纳秒等于十亿分之一秒（10-9秒）
1 纳秒 = 1000皮秒
1,000 纳秒 = 1微秒
1,000,000 纳秒 = 1毫秒
1,000,000,000 纳秒 = 1秒
*/
int NSSleep()
{
HANDLE hTimer = NULL;
LARGE_INTEGER liDueTime;
liDueTime.QuadPart = -390000;
// Create a waitable timer.
hTimer = CreateWaitableTimer(NULL, TRUE, "WaitableTimer");
if (!hTimer)
{
printf("CreateWaitableTimer failed (%d)\n", GetLastError());
return 1;
}
// Set a timer to wait for 10 seconds.
if (!SetWaitableTimer(
hTimer, &liDueTime, 0, NULL, NULL, 0))
{
printf("SetWaitableTimer failed (%d)\n", GetLastError());
return 2;
}
// Wait for the timer.
if (WaitForSingleObject(hTimer, INFINITE) != WAIT_OBJECT_0)
printf("WaitForSingleObject failed (%d)\n", GetLastError());
return 0;
}2、利用QueryPerformanceFrequency与QueryPerformanceCounter实现毫秒级延时
// 休眠指定毫秒数
void MSleep(long lTime)
{
LARGE_INTEGER litmp;
LONGLONG QPart1,QPart2;
double dfMinus, dfFreq, dfTim, dfSpec;
QueryPerformanceFrequency(&litmp);
dfFreq = (double)litmp.QuadPart;
QueryPerformanceCounter(&litmp);
QPart1 = litmp.QuadPart;
dfSpec = 0.000001*lTime;
do
{
QueryPerformanceCounter(&litmp);
QPart2 = litmp.QuadPart;
dfMinus = (double)(QPart2-QPart1);
dfTim = dfMinus / dfFreq;
}while(dfTim<dfSpec);
}3、利用timeSetEvent实现1ms定时器
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")
//定义1ms和2s时钟间隔，以ms为单位
#define ONE_MILLI_SECOND 1
//定义时钟分辨率，以ms为单位
#define TIMER_ACCURACY 1
volatile DWORD g_nCounter = 0;
volatile DWORD g_nCnt = 0;
DWORD g_nTicket = 0;
LARGE_INTEGER g_xliPerfFreq = {0};
LARGE_INTEGER g_xliPerfStart={0};
LARGE_INTEGER g_xliPerfNow={0};
int g_nSecond = 0;
MMRESULT g_mmTimerId = 0;
UINT g_wAccuracy = 0;
// 自己去实现一个PING函数, 网上大把就不发了
int StartPing()
{
return 1;
}
void CALLBACK TimerProc(UINT nID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD d2)
{
double dtime = 0.0f;
char szBuffer[MAX_PATH] = {0x00};
DWORD nTemp = 0;
if(nID == g_mmTimerId)
{
g_nCounter++;
g_nSecond += StartPing();
if(g_nCounter == 24)
{
QueryPerformanceCounter(&g_xliPerfNow);
dtime = ((double)(g_xliPerfNow.QuadPart - g_xliPerfStart.QuadPart) * 1000000.0f) / (double)g_xliPerfFreq.QuadPart;
if(dtime < 1000000.0f)
{
MSleep((1000000.0f - dtime));
}
QueryPerformanceCounter(&g_xliPerfNow);
dtime = ((double)(g_xliPerfNow.QuadPart - g_xliPerfStart.QuadPart) * 1000000.0f) / (double)g_xliPerfFreq.QuadPart;
nTemp = GetTickCount() - g_nTicket;
sprintf(szBuffer," [%04d] 执行时间 %d 毫秒, \t%.9f 微秒, \t延时: %d ms", g_nCnt, nTemp, dtime, g_nSecond);
cout<<szBuffer<<endl;
g_nTicket = GetTickCount();
memset(&g_xliPerfNow, 0x00, sizeof(LARGE_INTEGER));
memset(&g_xliPerfStart, 0x00, sizeof(LARGE_INTEGER));
memset(&g_xliPerfNow, 0x00, sizeof(LARGE_INTEGER));
QueryPerformanceFrequency(&g_xliPerfFreq);
QueryPerformanceCounter(&g_xliPerfStart);
g_nCnt++;
g_nCounter = 0;
g_nSecond = 0;
}
}
}
// 释放定时器
void FreeHighTimer()
{
if(g_mmTimerId == 0)
return;
timeKillEvent(g_mmTimerId);
timeEndPeriod(g_wAccuracy);
}
// 初始化高精度定时器
BOOL InitHighTimer()
{
TIMECAPS tc;
QueryPerformanceFrequency(&g_xliPerfFreq);
QueryPerformanceCounter(&g_xliPerfStart);
g_nTicket = GetTickCount();
//利用函数timeGetDeVCaps取出系统分辨率的取值范围，如果无错则继续；
if(timeGetDevCaps(&tc,sizeof(TIMECAPS)) == TIMERR_NOERROR)
{
//分辨率的值不能超出系统的取值范围
g_wAccuracy = min(max(tc.wPeriodMin, TIMER_ACCURACY), tc.wPeriodMax);
//调用timeBeginPeriod函数设置定时器的分辨率
timeBeginPeriod(g_wAccuracy);
// 设定41毫秒定时器
g_mmTimerId = timeSetEvent(41,0,TimerProc,NULL,TIME_PERIODIC);
if(g_mmTimerId == 0)
{
cout << "timeSetEvent failed: %d" << GetLastError() << endl;
return FALSE;
}
return TRUE;
}
return FALSE;
}每一秒耗时都是相对准确的，运行效果如下：
前面为GetTicket取出的毫秒，后面为每执行24次一个周期所消耗的微妙，最后一个为ping
本来是创建一个线程，再用方法1、2来休眠实现延时，但这种太低效率了而且不能保证误差，所以综上对比，强烈推荐第三种方法做高精度定时器！
