时间精度问题，我想让线程隔固定的时间做一件事，这个时间间隔可信吗？

Question

如题想让一个线程隔5ms干一件事，用SLEEP，听说时间精度不好，也有用GetTickXXXX的，还有用多媒体定时器的各位看看这中间哪种可以满足我的要求，能否说说其中的异同？我搜到的帖子没有全部说明白，只好再发帖问了~~分不够再加，期待弄懂这个问题，谢谢！

Answer 1

既然是5ms，还是用 DWORD GetTickCount(void) 吧，比较精确

Answer 2

DWORD dwStart = GetTickCount();MSDN上说GetTickCount() 得到的是毫秒值

Answer 3

http://community.csdn.net/Expert/topic/2663/2663023.xml?temp=.4788019
精华区的一个帖子还可以精确到微妙

Answer 4

被陌生人发现了:(
我也奉献一下吧
LONGLONG GetTimecount()
{
    LARGE_INTEGER litmp;
    QueryPerformanceCounter(&litmp);
    LONGLONG now = litmp.QuadPart;
    QueryPerformanceFrequency(&litmp);
    double frequce=(double)litmp.QuadPart;
    return LONGLONG (now * 1000 * 10 / frequce);
}
返回值以0.1ms为单位,如果要更高精度,自己调整那个1000 * 10的值,越大精度越高

Answer 5

我觉得用timeSetEvent也可以。它的最低精度是1ms

Answer 6

搞时间的多的就是
http://community.csdn.net/Expert/topic/2976/2976936.xml?temp=.8869593

Answer 7

到FAQ里面自己去查，多的就是

Answer 8

~晕,小猪,i have given it out......

Answer 9

被上面的各位前辈打败了~~~我汗~~学习ing暂不结帖，看后来的各位前辈有其他看法没有~我会另开帖结分，100分不够了：（各位继续，继续：）

Answer 10

应该没什么别的方案了吧,sohou提供的那篇贴子都精确到纳秒了,你还要怎么样:)

Answer 11

Window 98/xp/2k都达不到这个要求。
一个线程的switch都要25-100msWinCE勉强可行。

Answer 12

用black book里的zone计时器不错

Answer 13

计时器汇总，但楼主说的是隔5MS还有个回调呢。这个函数也许可行。
MMRESULT timeSetEvent(
  UINT           uDelay,      
  UINT           uResolution, 
  LPTIMECALLBACK lpTimeProc,  
  DWORD_PTR      dwUser,      
  UINT           fuEvent      
);
//best timecount!!!
class RdtscTimeCount
{
public:
RdtscTimeCount()
{
_overhead=0;
start();
stop();
_overhead=getPeriodCount();
}
public:
void start(){_start=getCycleCount();}
void stop(){_end=getCycleCount();}
public:
unsigned __int64 getPeriodCount() const {return _end-_start-_overhead; }
private:
unsigned __int64 _start;
unsigned __int64 _end;
unsigned __int64 _overhead;
unsigned __int64 getCycleCount(){_asm rdtsc}
};
class SystemTimeCount
{
public:
SystemTimeCount(){}
public:
void start(){::GetSystemTimeAsFileTime((LPFILETIME)&_start);}
void stop(){::GetSystemTimeAsFileTime((LPFILETIME)&_end);}
public:
unsigned __int64   getPeriodCount() const{return _end-_start;}
private:
unsigned __int64 _start;
unsigned __int64 _end;
};class MultiMediaCount
{
public:
MultiMediaCount(){}
public:
void start(){_start=::timeGetTime();}
void stop(){_end=::timeGetTime();}
public:
__int32   getPeriodCount() const{return _end-_start;}
private:
__int32 _start;
__int32 _end;
};
class TickCount
{
public:
TickCount(){}
public:
void start(){_start=::GetTickCount();}
void stop(){_end=::GetTickCount();}
public:
__int32 getPeriodCount() const {return _end-_start;}
private:
__int32 _start;
__int32 _end;
};
//
////============================================================
//class ProcessTimeCount
//{
//public:
// ProcessTimeCount():_handle(::GetCurrentProcess()){}
//public:
// void start()
// {
// FILETIME    creationTime, exitTime;
// ::GetProcessTimes(_handle, &creationTime, &exitTime, (LPFILETIME)&_kernelStart,(LPFILETIME)&_userStart);
// }
// void stop()
// {
// FILETIME    creationTime, exitTime;
// ::GetProcessTimes(_handle, &creationTime, &exitTime, (LPFILETIME)&_kernelEnd,(LPFILETIME)&_userEnd);
// }
//public:
// unsigned __int64   getKernelPeriodCount() const{return _kernelEnd-_kernelStart;}
// unsigned __int64   getUserPeriodCount() const{return _userEnd-_userStart;}
// unsigned __int64   getPeriodCount() const{return getKernelPeriodCount()+getUserPeriodCount();}
//private:
// HANDLE _handle;
//private:
// unsigned __int64  _kernelStart;
// unsigned __int64  _kernelEnd;
// unsigned __int64  _userStart;
// unsigned __int64  _userEnd;
//};
//
//class ThreadTimeCount
//{
//public:
// ThreadTimeCount():_handle(::GetCurrentThread()){}
//public:
// void start()
// {
// FILETIME    creationTime, exitTime;
// ::GetThreadTimes(_handle, &creationTime, &exitTime, (LPFILETIME)&_kernelStart,(LPFILETIME)&_userStart);
// }
// void stop()
// {
// FILETIME    creationTime, exitTime;
// ::GetThreadTimes(_handle, &creationTime, &exitTime, (LPFILETIME)&_kernelEnd,(LPFILETIME)&_userEnd);
// }
//public:
// unsigned __int64   getKernelPeriodCount() const{return _kernelEnd-_kernelStart;}
// unsigned __int64   getUserPeriodCount() const{return _userEnd-_userStart;}
// unsigned __int64   getPeriodCount() const{return getKernelPeriodCount()+getUserPeriodCount();}
//private:
// HANDLE _handle;
//private:
// unsigned __int64  _kernelStart;
// unsigned __int64  _kernelEnd;
// unsigned __int64  _userStart;
// unsigned __int64  _userEnd;
//};
//
//class HighPerformanceTimeCount
//{
//public:
// HighPerformanceTimeCount(){}
//public:
// void start()
// {
// ::QueryPerformanceFrequency((LARGE_INTEGER*)&_start);
// int ret=::QueryPerformanceFrequency((LARGE_INTEGER*)&_start);
// }
// void stop(){::QueryPerformanceFrequency((LARGE_INTEGER*)&_end);}
//public:
// unsigned __int64   getPeriodCount() const{return _end-_start;}
//private:
// unsigned __int64 _start;
// unsigned __int64 _end;
//};

Answer 14

Window 98/xp/2k都达不到这个要求。
一个线程的switch都要25-100msWinCE勉强可行。不会吧~~~调度要花这么多时间~~~~我汗~~~~如果一个进程里活动的线程只有二到三个，对时间间隔的精度有什么影响没有呢？？？

Answer 15

不是调度的时间，是一个线程如果得到时间片，除非主动让出CPU 时间片，否则这个线程就需要消耗
完它的时间片，才会让出给高级线程，或其他线程。