如何获取毫秒分辨率的 Windows 系统时间？

Question

如何获取毫秒分辨率的 Windows 系统时间？

如果上述不可能，那么我怎样才能获取操作系统的启动时间呢？我想将此值与 timeGetTime() 一起使用，以计算毫秒分辨率的系统时间。

Answer 1

从 Windows 8 开始，Microsoft 引入了新的 API 命令 GetSystemTimePreciseAsFileTime

不幸的是，如果您创建的软件也必须在较旧的操作系统上运行，则无法使用它。

我目前的解决方案如下，但要注意：确定的时间并不准确，只是接近实时时间。结果应始终小于或等于实际时间，但具有固定误差（除非计算机进入待机状态）。结果具有毫秒分辨率。就我的目的而言，这已经足够准确了。

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 + (uNow.QuadPart - uInitialCount.QuadPart) * 10000000 / uFrequency.QuadPart;
        
        if(uCurrentTime.QuadPart < uSystemTime.QuadPart || 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);
    }
}

Answer 2

GetSystemTimeAsFileTime 提供最佳精度任何用于绝对时间的 Win32 函数。正如 Joel Clark 所建议的，QPF/QPC 将提供更好的相对时间。

Answer 3

由于我们来这里都是为了快速的片段而不是无聊的解释，所以我会写一个：

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!)

不知道基于性能计数器的答案是如何上升的，不要做滑点错误，伙计们。

Answer 4

QueryPerformanceCounter() 专为细粒度计时器解析而构建。

它是系统必须提供的最高分辨率计时器，您可以在应用程序代码中使用它来识别性能瓶颈。

这是 C# 开发人员的简单实现：

    [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++) ;
        End();
        MessageBox.Show((m_endTime - m_startTime).ToString());
    }

如果您是 C/C++ 开发人员，请查看此处：如何使用 QueryPerformanceCounter Visual C++ 中对代码进行计时的函数

Answer 5

好吧，这个函数已经很老了，但 Windows C 库中还有另一个有用的函数 _ftime，返回一个结构体，其中包含本地时间time_t、毫秒、时区和夏令时标志。

Answer 6

在 C11 及更高版本（或 C++17 及更高版本）中，您可以使用 timespec_get () 以可移植的方式获得更高精度的时间

#include <stdio.h>
#include <time.h>
 
int main(void)
{
    struct timespec ts;
    timespec_get(&ts, TIME_UTC);
    char buff[100];
    strftime(buff, sizeof buff, "%D %T", gmtime(&ts.tv_sec));
    printf("Current time: %s.%09ld UTC\n", buff, ts.tv_nsec);
}

如果您使用的是 C++，那么从 C++11 开始，您可以使用 std::chrono::high_resolution_clock，std::chrono::system_clock（挂钟），或 std::chrono::steady_clock （单调时钟）在新的 标题。不再需要使用特定于 Windows 的 API

auto start1 = std::chrono::high_resolution_clock::now();
auto start2 = std::chrono::system_clock::now();
auto start3 = std::chrono::steady_clock::now();
// do some work
auto end1 = std::chrono::high_resolution_clock::now();
auto end2 = std::chrono::system_clock::now();
auto end3 = std::chrono::steady_clock::now();

std::chrono::duration<long long, std::milli> diff1 = end1 - start1;
std::chrono::duration<double, std::milli>    diff2 = end2 - start2;
auto diff3 = std::chrono::duration_cast<std::chrono::milliseconds>(end3 - start3);

std::cout << diff.count() << ' ' << diff2.count() << ' ' << diff3.count() << '\n';

Answer 7

试试 MSDN 杂志上的这篇文章。实际上相当复杂。

为 Windows 实现持续更新的高分辨率时间提供程序
(存档链接）

Answer 8

在 Windows 中，所有时间的基础是一个名为 GetSystemTimeAsFileTime 的函数。

• 它返回一个能够容纳 100 纳秒分辨率的时间的结构。
• 它以UTC保存，

FILETIME结构记录了自1600年1月1日以来100ns间隔的数量；这意味着它的分辨率被限制在100ns。

这构成了我们的第一个函数：

自 1600 年 1 月 1 日以来的 100 纳秒刻度的 64 位数字有些难以处理。 Windows 提供了一个方便的辅助函数 FileTimeToSystemTime，它可以将此 64 位整数解码为有用的部分：

record SYSTEMTIME {
   wYear: Word;
   wMonth: Word;
   wDayOfWeek: Word;
   wDay: Word;
   wHour: Word;
   wMinute: Word;
   wSecond: Word;
   wMilliseconds: Word;
}

请注意，SYSTEMTIME 具有 1ms< 的内置分辨率限制。 /code>

现在我们有办法从 FILETIME 到 SYSTEMTIME：

我们可以编写函数来获取当前系统时间作为SYSTEIMTIME 结构：

SYSTEMTIME GetSystemTime()
{
    //Get the current system time utc in it's native 100ns FILETIME structure
    FILETIME ftNow;
    GetSytemTimeAsFileTime(ref ft);

    //Decode the 100ns intervals into a 1ms resolution SYSTEMTIME for us
    SYSTEMTIME stNow;
    FileTimeToSystemTime(ref stNow);

    return stNow;
}

除了 Windows 已经为您编写了这样的函数：GetSystemTime

本地时间，而不是 UTC

现在，如果您不希望当前时间为 UTC 格式，该怎么办？如果您想在当地时间怎么办？ Windows 提供了将 UTC 格式的 FILETIME 转换为本地时间的函数： FileTimeToLocalFileTime

您可以编写一个返回 < 的函数code>FILETIME 在本地时间已经：

FILETIME GetLocalTimeAsFileTime()
{
   FILETIME ftNow;
   GetSystemTimeAsFileTime(ref ftNow);

   //convert to local
   FILETIME ftNowLocal
   FileTimeToLocalFileTime(ftNow, ref ftNowLocal);

   return ftNowLocal;
}

假设您要将本地 FILETIME 解码为 SYSTEMTIME。没问题，您可以再次使用 FileTimeToSystemTime：

幸运的是，Windows 已经为您提供了一个返回值的函数：

精确

有另一个考虑因素。在 Windows 8 之前，时钟的分辨率约为 15 毫秒。在 Windows 8 中，他们将时钟提高到 100ns（与 FILETIME 的分辨率相匹配）。

• GetSystemTimeAsFileTime （传统，15ms 分辨率）
• GetSystemTimePreciseAsFileTime （Windows 8，100ns 分辨率）

这意味着我们应该始终更喜欢新值：

您询问了时间

您询问了时间；但你有一些选择。

时区：

• UTC （系统本机）
• 本地时区

格式：

• FILETIME （系统本机，100ns 分辨率）
• SYTEMTIME （解码，1ms 分辨率）

摘要

• 100ns 分辨率：FILETIME
  • UTC：GetSytemTimePreciseAsFileTime （或 GetSystemTimeAsFileTime）
  • 本地：（您自己的）
• 1 毫秒分辨率：SYSTEMTIME< /代码>
  • UTC：GetSystemTime
  • 本地：GetLocalTime

Answer 9

这是对上述评论的详细阐述，以解释其中的一些原因。

首先， GetSystemTime* 调用是唯一提供系统时间的 Win32 API。这次的粒度相当粗，因为大多数应用程序不需要维持更高分辨率所需的开销。时间（可能）在内部存储为 64 位毫秒计数。调用timeGetTime获取低位32位。调用 GetSystemTime 等请求 Windows 在转换为天等并包括系统启动时间后返回此毫秒时间。

机器中有两个时间源：CPU 时钟和板载时钟（例如，实时时钟（RTC）、可编程间隔定时器（PIT）和高精度事件定时器（HPET））。第一个的分辨率约为 0.5ns (2GHz)，第二个通常可编程至 1ms 的周期（尽管较新的芯片 (HPET) 具有更高的分辨率）。 Windows 使用这些周期性的滴答声来执行某些操作，包括更新系统时间。

应用程序可以通过 timerBeginPeriod;然而，这会影响整个系统。操作系统将按照请求的频率检查/更新常规事件。在低 CPU 负载/频率下，存在空闲期以节省电量。在高频率下，没有时间将处理器置于低功耗状态。请参阅计时器分辨率< /a> 了解更多详情。最后，每个时钟周期都有一些开销，增加频率会消耗更多的 CPU 周期。

对于更高分辨率的时间，系统时间无法保持到这种精度，就像大本钟没有秒针一样。使用QueryPerformanceCounter (QPC) 或CPU 的刻度(rdtsc) 可以提供系统时间刻度之间的分辨率。 Kevin 引用的 MSDN 杂志文章中使用了这种方法。尽管这些方法可能存在漂移（例如，由于频率缩放）等，因此需要与系统时间同步。

Answer 10

GetTickCount 不会为您完成它。

查看QueryPerformanceFrequency / QueryPerformanceCounter。不过，这里唯一的问题是 CPU 扩展，所以请做好研究。