blocks|key|1142288|text|GetTickCount不会为您完成此操作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1142289|查看QueryPerformanceFrequency+/+QueryPerformanceCounter。这里唯一的问题是CPU的可伸缩性，所以做你的研究吧。|1142290|entityMap^0|0|C|0|2|P|U|N|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

<code>GetTickCount</code> will not get it done for you. 

Look into <code>QueryPerformanceFrequency</code> / <code>QueryPerformanceCounter</code>. The only gotcha here is CPU scaling though, so do your research.

blocks|key|1142329|text|请尝试这篇来自MSDN+Magazine的文章。这实际上相当复杂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1142330|Implement+a+Continuously+Updating,+High-Resolution+Time+Provider+for+Windows|offset|length|1142331|entityMap|0|LINK|mutability|MUTABLE|url|http://web.archive.org/web/20121018065403/http://msdn.microsoft.com/en-us/magazine/cc163996.aspx^0|0|0|24|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Try this article from MSDN Magazine. It's actually quite complicated.

<a href="http://web.archive.org/web/20121018065403/http://msdn.microsoft.com/en-us/magazine/cc163996.aspx" rel="nofollow noreferrer" title="Implement a Continuously Updating, High-Resolution Time Provider for Windows">Implement a Continuously Updating, High-Resolution Time Provider for Windows</a>

blocks|key|1142369|text|对于绝对时间，GetSystemTimeAsFileTime提供了任何Win32函数中最高的精度。Joel+Clark建议的QPF/QPC将提供更好的相对时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1142370|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms724397.aspx^0|7|N|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://msdn.microsoft.com/en-us/library/ms724397.aspx" rel="nofollow noreferrer">GetSystemTimeAsFileTime</a> gives the best precision of any Win32 function for absolute time. QPF/QPC as Joel Clark suggested will give better relative time.

blocks|key|1142445|text|这是对上述评论的详细阐述，以解释其中的一些原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1142446|首先，GetSystemTime*调用是唯一提供系统时间的Win32+API。此时间具有相当粗略的粒度，因为大多数应用程序不需要维护更高分辨率所需的开销。时间(可能)在内部存储为64位毫秒计数。调用timeGetTime获取低位32位。调用GetSystemTime，etc请求Windows在转换为天等并包含系统开始时间后返回此毫秒时间。|offset|length|1142447|机器中有两个时间源:CPU时钟和板载时钟(例如，实时时钟(RTC)、可编程间隔定时器(PIT)和高精度事件定时器(HPET))。前者的分辨率约为~0.5+is+(2+2GHz)，而后者通常可编程至1ms+(尽管较新的芯片(HPET)具有更高的分辨率)。Windows使用这些定期节拍来执行某些操作，包括更新系统时间。|1142448|应用程序可以通过timerBeginPeriod更改这段时间；但是，这会影响整个系统。操作系统将以请求的频率检查/更新常规事件。在CPU负载/频率较低的情况下，会有空闲期用于节能。在高频情况下，没有时间将处理器置于低功耗状态。有关更多详细信息，请参阅Timer+Resolution。最后，每个节拍都有一些开销，增加频率会消耗更多的CPU周期。|1142449|对于更高的分辨率时间，系统时间不会保持到这种精度，就像大本钟有秒针一样。使用QueryPerformanceCounter(QPC)或CPU的时钟周期(rdtsc)可以提供系统时间时钟周期之间的分辨率。凯文引用的MSDN杂志文章中就使用了这种方法。尽管这些方法可能具有漂移(例如，由于频率缩放)等，因此需要与系统时间同步。|1142450|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms724390%2528VS.85%2529.aspx|1|http://msdn.microsoft.com/en-us/library/dd757624%2528VS.85%2529.aspx|2|http://download.microsoft.com/download/3/0/2/3027D574-C433-412A-A8B6-5E0A75D5B237/Timer-Resolution.docx^0|0|3|D|0|0|0|8|G|1|3H|G|2|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|13|8|@]|9|@$D|14|E|15|1|16]|$D|17|E|18|1|19]]|A|$]]|$1|J|3|K|5|6|7|1A|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]|V|$5|O|P|Q|A|$R|W]]]]

This is an elaboration of the above comments to explain the some of the whys.

First, the <a href="http://msdn.microsoft.com/en-us/library/ms724390%28VS.85%29.aspx" rel="noreferrer">GetSystemTime</a>* calls are the only Win32 APIs providing the system's time. This time has a fairly coarse granularity, as most applications do not need the overhead required to maintain a higher resolution. Time is (likely) stored internally as a 64-bit count of milliseconds. Calling timeGetTime gets the low order 32 bits. Calling GetSystemTime, etc requests Windows to return this millisecond time, after converting into days, etc and including the system start time.

There are two time sources in a machine: the CPU's clock and an on-board clock (e.g., real-time clock (RTC), Programmable Interval Timers (PIT), and High Precision Event Timer (HPET)). The first has a resolution of around ~0.5ns (2GHz) and the second is generally programmable down to a period of 1ms (though newer chips (HPET) have higher resolution). Windows uses these periodic ticks to perform certain operations, including updating the system time.

Applications can change this period via <a href="http://msdn.microsoft.com/en-us/library/dd757624%28VS.85%29.aspx" rel="noreferrer">timerBeginPeriod</a>; however, this affects the entire system. The OS will check / update regular events at the requested frequency. Under low CPU loads / frequencies, there are idle periods for power savings. At high frequencies, there isn't time to put the processor into low power states. See <a href="http://download.microsoft.com/download/3/0/2/3027D574-C433-412A-A8B6-5E0A75D5B237/Timer-Resolution.docx" rel="noreferrer">Timer Resolution</a> for further details. Finally, each tick has some overhead and increasing the frequency consumes more CPU cycles.

For higher resolution time, the system time is not maintained to this accuracy, no more than Big Ben has a second hand. Using QueryPerformanceCounter(QPC) or the CPU's ticks (rdtsc) can provide the resolution between the system time ticks. Such an approach was used in the MSDN magazine article Kevin cited. Though these approaches may have drift (e.g., due to frequency scaling), etc and therefore need to be synced to the system time.

blocks|key|1142518|text|QueryPerformanceCounter()是为细粒度计时器解析而构建的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1142519|它是系统必须提供的最高精度计时器，您可以在应用程序代码中使用它来识别性能瓶颈|1142520|下面是C#开发人员的一个简单实现：|1142521|++++[DllImport("kernel32.dll")]
++++extern+static+short+QueryPerformanceCounter(ref+long+x);
++++[DllImport("kernel32.dll")]
++++extern+static+short+QueryPerformanceFrequency(ref+long+x);
++++private+long+m_endTime;
++++private+long+m_startTime;
++++private+long+m_frequency;

++++public+Form1()
++++{
++++++++InitializeComponent();
++++}
++++public+void+Begin()
++++{
++++++++QueryPerformanceCounter(ref+m_startTime);
++++}
++++public+void+End()
++++{
++++++++QueryPerformanceCounter(ref+m_endTime);
++++}

++++private+void+button1_Click(object+sender,+EventArgs+e)
++++{
++++++++QueryPerformanceFrequency(ref+m_frequency);
++++++++Begin();
++++++++for+(long+i+=+0;+i+<+1000;+i%2B%2B)+;
++++++++End();
++++++++MessageBox.Show((m_endTime+-+m_startTime).ToString());
++++}|code-block|syntax|javascript|1142522|如果你是一个C/C%2B%2B开发人员，那么看看这里：http://support.microsoft.com/kb/815668|offset|length|1142523|entityMap|0|LINK|mutability|MUTABLE|url|http://support.microsoft.com/kb/815668^0|0|0|0|0|N|12|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

QueryPerformanceCounter() is built for fine-grained timer resolution.

It is the highest resolution timer that the system has to offer that you can use in your application code to identify performance bottlenecks

Here is a simple implementation for C# devs:

<pre><code> [DllImport("kernel32.dll")]
 extern static short QueryPerformanceCounter(ref long x);
 [DllImport("kernel32.dll")]
 extern static short QueryPerformanceFrequency(ref long x);
 private long m_endTime;
 private long m_startTime;
 private long m_frequency;

 public Form1()
 {
 InitializeComponent();
 }
 public void Begin()
 {
 QueryPerformanceCounter(ref m_startTime);
 }
 public void End()
 {
 QueryPerformanceCounter(ref m_endTime);
 }

 private void button1_Click(object sender, EventArgs e)
 {
 QueryPerformanceFrequency(ref m_frequency);
 Begin();
 for (long i = 0; i &lt; 1000; i++) ;
 End();
 MessageBox.Show((m_endTime - m_startTime).ToString());
 }
</code></pre>

If you are a C/C++ dev, then take a look here:
<a href="http://support.microsoft.com/kb/815668" rel="nofollow">http://support.microsoft.com/kb/815668</a>

blocks|key|1142601|text|这是一个非常老的函数，但是在Windows+C库_ftime中还有另一个有用的函数，它返回一个本地时间为time_t、毫秒、时区和夏令时标志的结构。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1142602|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/z54t9z5f.aspx^0|O|6|1G|6|O|6|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Well, this one is very old, yet there is another useful function in Windows C library <a href="http://msdn.microsoft.com/en-us/library/z54t9z5f.aspx" rel="nofollow"><code>_ftime</code></a>, which returns a structure with local time as <code>time_t</code>, milliseconds, timezone, and daylight saving time flag.

blocks|key|1142636|text|在我对"Microsecond+resolution+timestamps+on+Windows"问题的回答中，我已经写了一些关于如何以适合大多数目的的方式快速、轻松地实现这一点的信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1142637|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/23832591/434413^0|3|1A|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I've written up some information about how to implement this quickly and easily, in a manner suitable for most purposes, in my answer to the <a href="https://stackoverflow.com/a/23832591/434413">"Microsecond resolution timestamps on Windows"</a> question.

blocks|key|1142695|text|从Windows8开始，微软引入了新的应用编程接口命令GetSystemTimePreciseAsFileTime：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1142696|https://msdn.microsoft.com/en-us/library/windows/desktop/hh706895%2528v=vs.85%2529.aspx|offset|length|1142697|不幸的是，如果你创建的软件也必须在旧的操作系统上运行，你就不能使用它。|1142698|我目前的解决方案如下，但请注意:确定的时间并不准确，它只是接近真实时间。结果应始终小于或等于实时，但具有固定的错误(除非计算机进入待机状态)。结果具有毫秒级的分辨率。就我的目的而言，它已经足够精确了。|1142699|void+GetHighResolutionSystemTime(SYSTEMTIME*+pst)
{
++++static+LARGE_INTEGER++++uFrequency+=+{+0+};
++++static+LARGE_INTEGER++++uInitialCount;
++++static+LARGE_INTEGER++++uInitialTime;
++++static+bool+++++++++++++bNoHighResolution+=+false;

++++if(!bNoHighResolution+&&+uFrequency.QuadPart+==+0)
++++{
++++++++//+Initialize+performance+counter+to+system+time+mapping
++++++++bNoHighResolution+=+!QueryPerformanceFrequency(&uFrequency);
++++++++if(!bNoHighResolution)
++++++++{
++++++++++++FILETIME+ftOld,+ftInitial;

++++++++++++GetSystemTimeAsFileTime(&ftOld);
++++++++++++do
++++++++++++{
++++++++++++++++GetSystemTimeAsFileTime(&ftInitial);
++++++++++++++++QueryPerformanceCounter(&uInitialCount);
++++++++++++}+while(ftOld.dwHighDateTime+==+ftInitial.dwHighDateTime+&&+ftOld.dwLowDateTime+==+ftInitial.dwLowDateTime);
++++++++++++uInitialTime.LowPart++=+ftInitial.dwLowDateTime;
++++++++++++uInitialTime.HighPart+=+ftInitial.dwHighDateTime;
++++++++}
++++}

++++if(bNoHighResolution)
++++{
++++++++GetSystemTime(pst);
++++}
++++else
++++{
++++++++LARGE_INTEGER+++uNow,+uSystemTime;

++++++++{
++++++++++++FILETIME++++ftTemp;
++++++++++++GetSystemTimeAsFileTime(&ftTemp);
++++++++++++uSystemTime.LowPart++=+ftTemp.dwLowDateTime;
++++++++++++uSystemTime.HighPart+=+ftTemp.dwHighDateTime;
++++++++}
++++++++QueryPerformanceCounter(&uNow);

++++++++LARGE_INTEGER+++uCurrentTime;
++++++++uCurrentTime.QuadPart+=+uInitialTime.QuadPart+%2B+(uNow.QuadPart+-+uInitialCount.QuadPart)+*+10000000+/+uFrequency.QuadPart;

++++++++if(uCurrentTime.QuadPart+<+uSystemTime.QuadPart+%7C%7C+abs(uSystemTime.QuadPart+-+uCurrentTime.QuadPart)+>+1000000)
++++++++{
++++++++++++//+The+performance+counter+has+been+frozen+(e.+g.+after+standby+on+laptops)
++++++++++++//+->+Use+current+system+time+and+determine+the+high+performance+time+the+next+time+we+need+it
++++++++++++uFrequency.QuadPart+=+0;
++++++++++++uCurrentTime+=+uSystemTime;
++++++++}

++++++++FILETIME+ftCurrent;
++++++++ftCurrent.dwLowDateTime++=+uCurrentTime.LowPart;
++++++++ftCurrent.dwHighDateTime+=+uCurrentTime.HighPart;
++++++++FileTimeToSystemTime(&ftCurrent,+pst);
++++}
}|code-block|syntax|javascript|1142700|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/windows/desktop/hh706895%2528v=vs.85%2529.aspx^0|0|0|2B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Starting with Windows 8 Microsoft has introduced the new API command GetSystemTimePreciseAsFileTime:

<a href="https://msdn.microsoft.com/en-us/library/windows/desktop/hh706895%28v=vs.85%29.aspx" rel="nofollow">https://msdn.microsoft.com/en-us/library/windows/desktop/hh706895%28v=vs.85%29.aspx</a>

Unfortunately you can't use that if you create software which must also run on older operating systems.

My current solution is as follows, but be aware: The determined time is not exact, it is only near to the real time. The result should always be smaller or equal to the real time, but with a fixed error (unless the computer went to standby). The result has a millisecond resolution. For my purpose it is exact enough.

<pre><code>void GetHighResolutionSystemTime(SYSTEMTIME* pst)
{
 static LARGE_INTEGER uFrequency = { 0 };
 static LARGE_INTEGER uInitialCount;
 static LARGE_INTEGER uInitialTime;
 static bool bNoHighResolution = false;

 if(!bNoHighResolution &amp;&amp; uFrequency.QuadPart == 0)
 {
 // Initialize performance counter to system time mapping
 bNoHighResolution = !QueryPerformanceFrequency(&amp;uFrequency);
 if(!bNoHighResolution)
 {
 FILETIME ftOld, ftInitial;

 GetSystemTimeAsFileTime(&amp;ftOld);
 do
 {
 GetSystemTimeAsFileTime(&amp;ftInitial);
 QueryPerformanceCounter(&amp;uInitialCount);
 } while(ftOld.dwHighDateTime == ftInitial.dwHighDateTime &amp;&amp; ftOld.dwLowDateTime == ftInitial.dwLowDateTime);
 uInitialTime.LowPart = ftInitial.dwLowDateTime;
 uInitialTime.HighPart = ftInitial.dwHighDateTime;
 }
 }

 if(bNoHighResolution)
 {
 GetSystemTime(pst);
 }
 else
 {
 LARGE_INTEGER uNow, uSystemTime;

 {
 FILETIME ftTemp;
 GetSystemTimeAsFileTime(&amp;ftTemp);
 uSystemTime.LowPart = ftTemp.dwLowDateTime;
 uSystemTime.HighPart = ftTemp.dwHighDateTime;
 }
 QueryPerformanceCounter(&amp;uNow);

 LARGE_INTEGER uCurrentTime;
 uCurrentTime.QuadPart = uInitialTime.QuadPart + (uNow.QuadPart - uInitialCount.QuadPart) * 10000000 / uFrequency.QuadPart;

 if(uCurrentTime.QuadPart &lt; uSystemTime.QuadPart || abs(uSystemTime.QuadPart - uCurrentTime.QuadPart) &gt; 1000000)
 {
 // The performance counter has been frozen (e. g. after standby on laptops)
 // -&gt; Use current system time and determine the high performance time the next time we need it
 uFrequency.QuadPart = 0;
 uCurrentTime = uSystemTime;
 }

 FILETIME ftCurrent;
 ftCurrent.dwLowDateTime = uCurrentTime.LowPart;
 ftCurrent.dwHighDateTime = uCurrentTime.HighPart;
 FileTimeToSystemTime(&amp;ftCurrent, pst);
 }
}
</code></pre>

blocks|key|928270|text|既然我们都来这里只是为了简单的片段，而不是无聊的解释，我就写一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|928271|FILETIME+t;
GetSystemTimeAsFileTime(&t);+//+unusable+as+is

ULARGE_INTEGER+i;
i.LowPart+=+t.dwLowDateTime;
i.HighPart+=+t.dwHighDateTime;

int64_t+ticks_since_1601+=+i.QuadPart;+//+now+usable
int64_t+us_since_1601+++=+(i.QuadPart+*+1e-1);
int64_t+ms_since_1601+++=+(i.QuadPart+*+1e-4);
int64_t+sec_since_1601++=+(i.QuadPart+*+1e-7);

//+unix+epoch
int64_t+unix_us++=+(i.QuadPart+*+1e-1)+-+11644473600LL+*+1000000;
int64_t+unix_ms++=+(i.QuadPart+*+1e-4)+-+11644473600LL+*+1000;
double++unix_sec+=+(i.QuadPart+*+1e-7)+-+11644473600LL;

//+i.QuadPart+is+#+of+100ns+ticks+since+1601-01-01T00:00:00Z
//+difference+to+Unix+Epoch+is+11644473600+seconds+(attention+to+units!)|code-block|syntax|javascript|928272|不知道漂移性能-基于计数器的答案是如何上升的，不要做滑移错误，伙计们。|928273|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Since we all come here for quick snippets instead of boring explanations, I'll write one:

<pre><code>FILETIME t;
GetSystemTimeAsFileTime(&amp;t); // unusable as is

ULARGE_INTEGER i;
i.LowPart = t.dwLowDateTime;
i.HighPart = t.dwHighDateTime;

int64_t ticks_since_1601 = i.QuadPart; // now usable
int64_t us_since_1601 = (i.QuadPart * 1e-1);
int64_t ms_since_1601 = (i.QuadPart * 1e-4);
int64_t sec_since_1601 = (i.QuadPart * 1e-7);

// unix epoch
int64_t unix_us = (i.QuadPart * 1e-1) - 11644473600LL * 1000000;
int64_t unix_ms = (i.QuadPart * 1e-4) - 11644473600LL * 1000;
double unix_sec = (i.QuadPart * 1e-7) - 11644473600LL;

// i.QuadPart is # of 100ns ticks since 1601-01-01T00:00:00Z
// difference to Unix Epoch is 11644473600 seconds (attention to units!)
</code></pre>

No idea how drifting performance-counter-based answers went up, don't do slippage bugs, guys.

How can I get the Windows system time with millisecond resolution?

If the above is not possible, then how can I get the operating system start time? I would like to use this value together with timeGetTime() in order to compute a system time with millisecond resolution.

Thank you in advance.

How can I get the Windows system time with millisecond resolution?

Windows

Unix

如何获得毫秒级分辨率的Windows系统时间？如果以上都不可能，那么我如何获取操作系统的启动时间？我想把这个值和timeGetTime()一起用来计算毫秒级的系统时间。提前谢谢你。

问如何获得毫秒级分辨率的Windows系统时间？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获得毫秒级分辨率的Windows系统时间？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获得毫秒级分辨率的Windows系统时间？
EN