封装几个代码，方便以后查询和使用
 
Windows高精度时钟 精度：<1us 微秒
 
1.1Function 1统计一段代码的CPU时间
 
	LARGE_INTEGER freq;
	LARGE_INTEGER beginTime;
	LARGE_INTEGER endTime;

	QueryPerformanceFrequency(&freq);
	QueryPerformanceCounter(&beginTime);
	//测试代码块时间 Begin
	
    //测试代码块时间 End
    QueryPerformanceCounter(&endTime);
    double second = (double)(endTime.QuadPart - beginTime.QuadPart) / (double)freq.QuadPart;
 
1.2更方便的宏定义
 
#define COUNT_BEGIN  LARGE_INTEGER freq,beginTime,LARGE_INTEGER endTime;\
QueryPerformanceFrequency(&freq);\
QueryPerformanceCounter(&beginTime);

#define COUNT_END QueryPerformanceCounter(&endTime);
#define SHOW_TIME_COUNT printf("%llf second passed\n",(double)(endTime.QuadPart - beginTime.QuadPart) / (double)freq.QuadPart;);
 
2.1Function 2高精度Sleep()
 
LARGE_INTEGER freq;  
LARGE_INTEGER start, end;  
QueryPerformanceFrequency(&freq);  
unsigned int s = 0; //此处填入延时的秒数
unsigned int ms = 0; //此处填入延时的毫秒数
unsigned int us = 100000; //此处填入需要延时的微秒数  
us += ms*1000+s*1000*1000;
LONGLONG count = (us * freq.QuadPart) / (1000 * 1000);  
QueryPerformanceCounter(&start);  
count = count + startQuadPart ;  
do  
{  
   QueryPerformanceCounter(&end);  
}while(end.QuadPart< count);  
 
2.2 更方便的宏定义
 
#define SLEEP_S(S)
LARGE_INTEGER freq;  \
LARGE_INTEGER start, end;  \
QueryPerformanceFrequency(&freq);  \
LONGLONG count = (S*1000*1000 * freq.QuadPart) / (1000 * 1000);  \
QueryPerformanceCounter(&start);  \
count = count + startQuadPart ;  \
do  \
{  \
   QueryPerformanceCounter(&end);  \
}while(end.QuadPart< count);  

#define SLEEP_MS(MS)
LARGE_INTEGER freq;  \
LARGE_INTEGER start, end;  \
QueryPerformanceFrequency(&freq);  \
LONGLONG count = (S*1000 * freq.QuadPart) / (1000 * 1000);  \
QueryPerformanceCounter(&start);  \
count = count + startQuadPart ;  \
do  \
{  \
   QueryPerformanceCounter(&end);  \
}while(end.QuadPart< count);  

#define SLEEP_US(US)
LARGE_INTEGER freq;  \
LARGE_INTEGER start, end;  \
QueryPerformanceFrequency(&freq);  \
LONGLONG count = (US * freq.QuadPart) / (1000 * 1000);  \
QueryPerformanceCounter(&start);  \
count = count + startQuadPart ;  \
do  \
{  \
   QueryPerformanceCounter(&end);  \
}while(end.QuadPart< count);  

Windows有个多媒体时钟函数：
  
  
 
timeGetTime
   
 
The timeGetTime function retrieves the system time, in milliseconds. The system time is the time elapsed since Windows was started.
  
 
DWORD timeGetTime(VOID); 
   
 

  
    
  
 
单位为毫秒，精度比较高，使用时需要包含 "mmsystem.h"文件，并在工程中加入"winmm.lib" 文件。
  
 

  
    
  
 
另外Windows还提供了QueryPerformanceCounter函数可以取得高精度的当前的时钟周期数，因此可以用此函数写出比timeGetTime精度更高的记时器函数。
  
 

  
    
  
 
// 取得CPU每秒时间内的时钟周期数
  
 
__inline LONGLONG GetSecondCount()
  
 
{
  
 
       static LARGE_INTEGER liCounter = {0};
  
 
       if (0 == liCounter.QuadPart)
  
 
              QueryPerformanceFrequency(&liCounter);
  
 
       return liCounter.QuadPart;
  
 
}
  
 

  
    
  
 
// 返回当前时间 单位：毫秒
  
 
__inline DWORD highGetTime()
  
 
{
  
 
       LARGE_INTEGER liCurrent = {0};
  
 
       QueryPerformanceCounter(&liCurrent);
  
 
       return (DWORD)(liCurrent.QuadPart * 1000 / GetSecondCount());
  
 
}
  
 

  
    
  
 

  
    
  
 
为了测试各时钟函数的精度究竟如何，笔者写了如下测试程序：
  
 

  
    
  
 
一  GetTickCount()
  
 

  
    
  
 
#include "conio.h"
  
 
#include "windows.h"
  
 

  
    
  
 
void main()
  
 
{
  
 
       Sleep(1000);
  
 
       
  
 
       DWORD old_time = GetTickCount();
  
 
       for (int i = 0; i < 10; ++i)
  
 
       {
  
 
              int n = 0;
  
 
              for (int j = 0; j < 500000; ++j)
  
 
              {
  
 
                     if (j % 10 == 0)
  
 
                            n--;
  
 
                     else
  
 
                            n++;
  
 
              }
  
 
              DWORD time = GetTickCount();
  
 
              DWORD dt = time - old_time;
  
 
              old_time = time;
  
 
              printf("n = %d  耗时：%d/n", n, dt);
  
 
       }
  
 
       
  
 
       _getch();
  
 
}
  
 

  
    
  
 
输出结果：
 
n = 400000  耗时：0
  
 
n = 400000  耗时：16
  
 
n = 400000  耗时：0
  
 
n = 400000  耗时：15
  
 
n = 400000  耗时：16
  
 
n = 400000  耗时：0
  
 
n = 400000  耗时：16
  
 
n = 400000  耗时：0
  
 
n = 400000  耗时：15
  
 
n = 400000  耗时：16
  
 

  
    
  
 

  
    
  
 

  
    
  
 
二  timeGetTime ()
  
 

  
    
  
 
#include "conio.h"
  
 
#include "windows.h"
  
 
#include "mmsystem.h"
  
 
#pragma comment(lib, "winmm.lib")
  
 

  
    
  
 
void main()
  
 
{
  
 
       Sleep(1000);
  
 
       
  
 
       DWORD old_time = timeGetTime();
  
 
       for (int i = 0; i < 10; ++i)
  
 
       {
  
 
              int n = 0;
  
 
              for (int j = 0; j < 500000; ++j)
  
 
              {
  
 
                     if (j % 10 == 0)
  
 
                            n--;
  
 
                     else
  
 
                            n++;
  
 
              }
  
 
              DWORD time = timeGetTime();
  
 
              DWORD dt = time - old_time;
  
 
              old_time = time;
  
 
              printf("n = %d  耗时：%d/n", n, dt);
  
 
       }
  
 
       
  
 
       _getch();
  
 
}
  
 

  
    
  
 
输出结果：
 
n = 400000  耗时：0
  
 
n = 400000  耗时：15
  
 
n = 400000  耗时：16
  
 
n = 400000  耗时：15
  
 
n = 400000  耗时：16
  
 
n = 400000  耗时：16
  
 
n = 400000  耗时：15
  
 
n = 400000  耗时：0
  
 
n = 400000  耗时：16
  
 
n = 400000  耗时：16
  
 

  
    
  
 

  
    
  
 
三  highGetTime ()
  
 

  
    
  
 
#include "conio.h"
  
 
#include "windows.h"
  
 

  
    
  
 
__inline LONGLONG GetSecondCount()
  
 
{
  
 
       static LARGE_INTEGER liCounter = {0};
  
 
       if (0 == liCounter.QuadPart)
  
 
              QueryPerformanceFrequency(&liCounter);
  
 
       return liCounter.QuadPart;
  
 
}
  
 

  
    
  
 
// 返回当前时间 单位：毫秒
  
 
__inline DWORD highGetTime()
  
 
{
  
 

  
    
  
 
       LARGE_INTEGER liCurrent = {0};
  
 
       QueryPerformanceCounter(&liCurrent);
  
 
       return (DWORD)(liCurrent.QuadPart * 1000 / GetSecondCount());
  
 
}
  
 

  
    
  
 
void main()
  
 
{
  
 
       Sleep(1000);
  
 
       
  
 
       DWORD old_time = highGetTime();
  
 
       for (int i = 0; i < 10; ++i)
  
 
       {
  
 
              int n = 0;
  
 
              for (int j = 0; j < 500000; ++j)
  
 
              {
  
 
                     if (j % 10 == 0)
  
 
                            n--;
  
 
                     else
  
 
                            n++;
  
 
              }
  
 
              DWORD time = highGetTime();
  
 
              DWORD dt = time - old_time;
  
 
              old_time = time;
  
 
              printf("n = %d  耗时：%d/n", n, dt);
  
 
       }
  
 
       
  
 
       _getch();
  
 
}
  
 

  
    
  
 
输出结果：
 
n = 400000  耗时：10
 
n = 400000  耗时：9
 
n = 400000  耗时：10
 
n = 400000  耗时：10
 
n = 400000  耗时：9
 
n = 400000  耗时：10
 
n = 400000  耗时：10
 
n = 400000  耗时：10
 
n = 400000  耗时：10
 
n = 400000  耗时：10
 

  
    
  
 

  
    
  
 
以上三个测试程序均完成同样的工作10次，那么每次耗费的时间应该相差不大才对，根据程序输出的结果，我们可以看出：timeGetTime 比 GetTickCount精度高，highGetTime精度最高。

原文地址：http://www.ituring.com.cn/article/1828?q=settimeout
 
 Nicholas C. Zakas发表于2011年12月14日上午7：00
 
 标签：JavaScript,性能,时钟
 
 时钟精度是指时钟更新的频率，大部分情况下，网络浏览器使用诸如setTimeout() 和setInterval()的函数调用系统默认时钟，这意味着浏览器部署代码时只能和系统时钟同步。Internet Explorer的日期对象（Date Object）也把系统时钟作为种子值，因此日期对象的差异也就只能用时钟精度来衡量。
 
 历史简介
 
 Windows机器默认时钟精度为10-15.6毫秒（大部分情况是15.6毫秒），亦即浏览器采用的系统时钟遵循该时钟精度。当然，以目前CPU处理器速度而言，10-15.6毫秒是一个极限。IE浏览器到IE 8都还独占系统时钟，以至于John Resig撰文阐释时间精度如何影响基准程序1也就不足为奇了。但是，OS X下浏览器时钟较Windows下更为精确。
 
 直到最近，Window下其他浏览器也使用系统时钟，遵循15.6毫秒的时钟精度，这在Firefox、Safari和Opera均得到体现。Chrome应该是首个采用高精度时钟的Windows浏览器2，他们的实验有一些有趣的结论。
 
 他们最初的想法是让Chrome使用亚毫秒级精度的时钟，但后来放弃了，并换用1毫秒精度。他们决定采用Windows多媒体时钟API，这能够给定达到1毫秒精度的时钟并用以此替代系统时钟。这和Flash和Quicktime等插件使用的时钟相同。
 
 Chrome 1.0 beta版采用了1毫秒的时钟精度。这看起来不错，但运行时却收到许多bug报告。1毫秒精度的时钟导致CPU高速运转，当CPU运转时，因不能进入睡眠模式（低耗电）而耗电增加3。这使得Chrome将时钟精度延长到4毫秒。
 
 这4毫秒的延迟在HTML5中作为时钟部分被记录下来4，HTML5认为setTimeout()的最小精度应为4毫秒。而setInterval ()的最小精度被设定为10毫秒。
 
 目前的时钟精度
 
 和Chrome一样，IE9、Firefox 5、Safari 5.1和 Opera 11也都跟着采用了4毫秒的时钟精度。此前，Firefox 4和Safari 5及它们的早期版本采用的是10毫秒的时钟精度（显然，这是在WebKit内核固定的）。iOS 5上Safari移动浏览器也采用4毫秒精度，Kindle Fire上的Silk采用10毫秒精度，这暗示了它可能是在老版本的WebKit平台上开发的。然而，正因为目前浏览器普遍采用4毫秒精度，并不意味着那就是你能获得的精度。
 
 大部分浏览器基于不同情况都会采取一些调节措施（使得时钟精度延迟），目的在于在合适时候保护电池——理论上讲，这些时间用户既不会察觉出异样也愿意为延长笔记本或移动设备电池寿命（做些让步）。下面这些情况时钟精度会做相应调整：
 
当笔记本使用电池电源时，Chrome 和 IE 9+自动回调到系统时钟，而换上交流电源时又调整到4毫秒精度。
Firefox 5+、 Chrome 11+和IE 10+对未激活的tab页面使用1000毫秒的时钟精度5。
使用其他应用程序时，iOS5上的Safari移动浏览器和Kindle Fire上的Silk完全冻结时钟，直至再次使用浏览器时才解冻。
 
 浏览器往往不断调节适应时钟精度以适应电池供电设备的耗电。HTML5特地为浏览器开发人员预留了完成该调整的空间。
 
 结论
 
 随着浏览器近年来的发展，时钟精度一直在悄悄的改进。时钟精度并非经常讨论的热门话题，但当使用setTimeout() 和 setInterval()时，需要对其功能加以深入理解。我们越来越接近对浏览器的每毫秒的监控了，一旦有人解决了高精度时钟运行时的CPU崩溃问题，我们将很可能看到时钟精度的再次提高。但在这之前，记住4毫秒的限值，且牢记我们往往达不到这种状态。
 
 2011年12月15日更新：更新了关于日期对象的相关信息。
 
 参考文献
 
 
 Accuracy of JavaScript Time by John Resig
 
 JavaScript时间精度 John Resig
 
 
 Chrome: Cranking up the clock by Mike Belshe
 
 Chrome：启动时钟管理 Mike Belshe
 
 
 CPU Power Utilization on Intel® Architectures by Karthik Krishnan
 
 Intel®架构下的CPU电力使用 Karthik Krishnan
 
 
 Timers in HTML5
 
 HTML5下的时间设置
 
 
 Clamp setTimeout/setInterval to something higher than 10ms in inactive tabs
 
 对未激活标签页（tabs）中高于10毫秒精度对象强制设定时钟（setTimeout/setInterval）
 
 
 Timer Resolution Test by Ryan Grove
 
 时钟精度测试 Ryan Grove
 
 
 声明：本文所有观点和意见来自Nicholas C. Zakas，无论如何，请勿关联我的雇主、同事、Wrox出版社、O'Reilly出版社或者其它任何人。我仅表达自己的观点，而非为他人。
 
 原文标题：Timer resolution in browsers
 
 原文地址：http://www.nczonline.net/blog/2011/12/14/timer-resolution-in-browsers

背景
 
　　在实际工作过程中，比如与硬件交互、媒体视频播放、性能分析以及多线程任务同步时，可能需要在windows平台下实现ms级别精度的定时器。然而，这种需求虽然存在，但是由于windows系统并不是一个实时操作系统，实现这种精度的定时器，并不是一件容易的事情。
 
 
 
Windows 不是实时操作系统，所以任何方案都无法绝对保证定时器的精度，只是能尽量减少误差。所以，系统的稳定性不能完全依赖于定时器，必须考虑失去同步时的处理。
 
 
等待策略
 
　　要想实现高精度定时器，必须需要等待和计时两种基础功能，等待用来跳过一定时间间隔，计时可以进行时间检查，用以调整等待事件。 
 等待策略实际就是两种： 
 1. 自旋等待：让CPU空转消耗时间，占用大量CPU时间，但是时间高度可控。 
 2. 阻塞等待：线程进入阻塞状态，让出CPU时间片，在等待一定时间后再由操作系统调度回到运行状态。阻塞时不占用CPU，然而需要操作系统调度，时间难以控制。 
 　　可以看到二者各有优劣，应该按照不同需求进行不同的实现。 
 所以难点在于等待策略，下面先分析简单的自旋等待。
 
自旋等待
 
伪代码如下：
 

等待开始时间=当前计时
while((当前计时-等待开始时间)<需要等待的时间)    
{
    自旋；
}
 
阻塞等待
 
　　阻塞等待会把控制权交给操作系统，这样就必须确保操作系统能够及时的将定时器线程调度回运行状态。默认情况下，Windows的系统定时器精度为15.625ms,也就是说时间切片是这个尺寸。如果线程阻塞，出让其时间片进行等待，再被调度运行的时间至少是一个切片15.625ms。那么必须减少时间切片的长度,才能实现更高的精度。 
 　一般实现阻塞等待都用的是thread库的sleep函数,实测sleep函数的精度不高，估计也就ms级的,也就是可能会产生+1ms的误差。 
 　sleep会出让剩余的cpu时间片给优先级相同的线程，而yield则是出让剩余的cpu时间片给运行在同一核心上的线程。在出让的时间片结束后，其会被重新调度。一般情况下，整个过程可以在1ms内完成。
 
 
 
另外，sleep或者yield在CPU高负载情况下非常不稳定，实测可能会阻塞高达几ms的时间，所以可能会产生更多的误差，因此误差修正最好采用自旋方式实现。
 
 
定时器实现
 
　　需要注意的是，无论自选还是阻塞，显然定时器都应该运行在独立的线程，不能干扰使用方线程工作。而对于高精度定时器而言，触发事件以执行任务的线程一般都在定时器线程内，而不是再使用独立的任务线程。 
 　　这是因为在高精度定时场景下，任何任务的时间开销很可能大于定时器的时间间隔，如果默认就在其他线程执行任务，可能导致占用大量线程。所以应该把控制权交给用户，让用户在需要的时候自行调度任务执行的线程。
 
触发模式
 
　　由于在定时器线程执行任务，所以定时器的触发就产生了三种模式。以下是三种模式的伪代码：
 
固定时间框架 
 比如间隔10ms,任务 7-12ms，则会按照等待 10ms 、任务 7ms、等待 3ms、任务 12ms（超时 2ms 失去同步）、任务 7ms、等待 1ms（回到同步）、任务 7ms、等待 3ms、… 进行。就是尽量按照设定好的时间框架来执行任务，只要任务不是始终超时，就可以回到原本的时间框架上。
 
var 下一帧时间=0
while(定时器开始)
{
    下一帧时间+=间隔时间
    while(当前时间<下一帧时间)
    {
    等待；
    }
    触发任务；
}
 
2.可推迟时间框架 
 上面的例子会按照等待 10ms 、任务 7ms、等待 3ms、任务 12ms（超时，推迟时间框架 2ms）、任务 7ms、等待 3ms、… 进行。超时的任务会推迟时间框架。
 
var 下一帧时间 = 0;
while(定时器开启)
{
    下一帧时间 += 间隔时间;
    if (下一帧时间 < 当前计时)
        下一帧时间 = 当前计时
    while (当前计时 < 下一帧时间)
    {
        等待;
    }
    触发任务;
}
 
3.固定等待框架 
 上面的例子会按照等待 10ms、任务 7ms、等待 10ms、任务 12ms、等待 10ms、任务 7ms… 进行。等待时间始终不变。
 
while(定时器开启)
{
    var 等待开始时间 = 当前计时;
    while ((当前计时 - 等待开始时间) < 间隔时间)
    {
        等待;
    }
    触发任务;
}
// 或者：
var 下一帧时间 = 0;
while(定时器开启)
{
    下一帧时间 += 间隔时间;
    while (当前计时 < 下一帧时间)
    {
        等待;
    }
    触发任务;
    下一帧时间 = 当前计时;
}
 
　　在while循环中的等待可以使用自旋或阻塞，也可以结合它们来达到精度、稳定性和 CPU 开销的平衡。 
 　　另外，由上面的伪代码可以看出，这三种模式的实现可以统一，能够做到根据情况切换。
 
实现
 
　　为了实现高精度的定时器，我们不采用阻塞模式(sleep函数和yield函数)，而是采用QueryPerformanceFrequency()和QueryPerformanceCounter()函数。这两个函数是Visual C++提供并且仅供Windows 95及其后续版本使用，其精度与CPU的时钟频率有关，它们要求计算机从硬件上支持精确定时器。。QueryPerformanceFrequency()函数和QueryPerformanceCounter()函数的原型如下：
 
BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);
BOOL QueryPerformanceCounter(LARGE_INTEGER *lpCount);
 
上述两个函数的参数的数据类型LARGE_INTEGER既可以是一个8字节长的整型数，也可以是两个4字节长的整型数的联合结构，其具体用法根据编译器是否支持64位而定。该类型的定义如下：
 
typedef union _LARGE_INTEGER
{
    struct
    {
        DWORD LowPart; // 4字节整型数
        LONG HighPart; // 4字节整型数
    };
    LONG QuadPart; // 8字节整型数
}LARGE_INTEGER;
 
使用QueryPerformanceFrequency()和QueryPerformanceCounter()函数进行精确定时的步骤如下：
 
首先调用QueryPerformanceFrequency()函数取得高精度运行计数器的频率f，单位是每秒多少次（n/s），此数一般很大;
在需要定时的代码的两端分别调用QueryPerformanceCounter()以取得高精度运行计数器的数值n1、n2，两次数值的差值通过f换算成时间间隔，t=(n2-n1)/f，当t大于或等于定时时间长度时，启动定时器; 
 下面给出一个简单的计算时间的例子：
 
LARGE_INTEGER m_liPerfFreq={0};
 //获取每秒多少CPU Performance Tick
 QueryPerformanceFrequency(&m_liPerfFreq); 
 LARGE_INTEGER m_liPerfStart={0};
 QueryPerformanceCounter(&m_liPerfStart);
 for(int i=0; i< 100; i++)
  cout << i << endl;
 LARGE_INTEGER liPerfNow={0};
 // 计算CPU运行到现在的时间
 QueryPerformanceCounter(&liPerfNow);
 int time=( ((liPerfNow.QuadPart - m_liPerfStart.QuadPart) * 1000)/m_liPerfFreq.QuadPart);
 char buffer[100];
 sprintf(buffer,"執行時間 %d millisecond ",time);
 cout<<buffer<<endl;
 
下列再由此实现1ms的精确定时：
 
  LARGE_INTEGER litmp; 
       LONGLONG QPart1,QPart2;
       double dfMinus, dfFreq, dfTim; 
       QueryPerformanceFrequency(&litmp);
       dfFreq = (double)litmp.QuadPart;// 获得计数器的时钟频率
       QueryPerformanceCounter(&litmp);
       QPart1 = litmp.QuadPart;// 获得初始值
       do
       {
          QueryPerformanceCounter(&litmp);
          QPart2 = litmp.QuadPart;//获得中止值
          dfMinus = (double)(QPart2-QPart1);
          dfTim = dfMinus / dfFreq;// 获得对应的时间值，单位为秒
       }while(dfTim<0.001);
 
　　根据上述定时器，再结合之前的定时与任务的框架，就可以实现高精度的定时器，精度可以达到us级别。基本上可以满足大部分的对实时要求很高任务了。