time.get_clock_info(name)

获取有关指定时钟的信息。支持的时钟名称

• "clock"：time.clock()
• "monotonic"：time.monotonic()
• "perf_counter"：time.perf_counter()
• "process_time"：time.process_time()
• "time"：time.time()

返回一个 time.clock_info 对象，该对象具有以下属性

• implementation (str)：底层操作系统函数的名称。示例："QueryPerformanceCounter()"、"clock_gettime(CLOCK_REALTIME)"。
• monotonic (bool)：如果时钟无法倒退，则为 True。
• adjustable (bool)：如果时钟可以自动更改（例如，由 NTP 守护程序）或由系统管理员手动更改，则为 True，否则为 False
• resolution (float)：时钟的分辨率（以秒为单位）。

time.monotonic()

单调时钟，即无法倒退。它不受系统时钟更新的影响。返回的值的参考点是未定义的，因此只有连续调用结果之间的差才是有效的，并且是一个秒数。

在 Vista 之前的 Windows 版本中，time.monotonic() 检测到 GetTickCount() 整数溢出（32 位，在 49.7 天后回滚）。它在每次检测到溢出时将内部纪元（参考时间）增加 2³²。纪元存储在进程本地状态中，因此在运行超过 49 天的两个 Python 进程中，time.monotonic() 的值可能不同。在更新版本的 Windows 和其他操作系统上，time.monotonic() 是系统范围的。

可用性：Windows、Mac OS X、Linux、FreeBSD、OpenBSD、Solaris。在 GNU/Hurd 上不可用。

伪代码 [2]

if os.name == 'nt':
    # GetTickCount64() requires Windows Vista, Server 2008 or later
    if hasattr(_time, 'GetTickCount64'):
        def monotonic():
            return _time.GetTickCount64() * 1e-3
    else:
        def monotonic():
            ticks = _time.GetTickCount()
            if ticks < monotonic.last:
                # Integer overflow detected
                monotonic.delta += 2**32
            monotonic.last = ticks
            return (ticks + monotonic.delta) * 1e-3
        monotonic.last = 0
        monotonic.delta = 0

elif sys.platform == 'darwin':
    def monotonic():
        if monotonic.factor is None:
            factor = _time.mach_timebase_info()
            monotonic.factor = timebase[0] / timebase[1] * 1e-9
        return _time.mach_absolute_time() * monotonic.factor
    monotonic.factor = None

elif hasattr(time, "clock_gettime") and hasattr(time, "CLOCK_HIGHRES"):
    def monotonic():
        return time.clock_gettime(time.CLOCK_HIGHRES)

elif hasattr(time, "clock_gettime") and hasattr(time, "CLOCK_MONOTONIC"):
    def monotonic():
        return time.clock_gettime(time.CLOCK_MONOTONIC)

在 Windows 上，即使 QueryPerformanceCounter() 的分辨率高于 GetTickCount()，也不会使用它。它不可靠，并且存在太多问题。

time.perf_counter()

具有最高可用分辨率的性能计数器，用于测量短时间段。它包括睡眠期间经过的时间，并且是系统范围的。返回的值的参考点是未定义的，因此只有连续调用结果之间的差才是有效的，并且是一个秒数。

它在所有平台上都可用。

伪代码

if os.name == 'nt':
    def _win_perf_counter():
        if _win_perf_counter.frequency is None:
            _win_perf_counter.frequency = _time.QueryPerformanceFrequency()
        return _time.QueryPerformanceCounter() / _win_perf_counter.frequency
    _win_perf_counter.frequency = None

def perf_counter():
    if perf_counter.use_performance_counter:
        try:
            return _win_perf_counter()
        except OSError:
            # QueryPerformanceFrequency() fails if the installed
            # hardware does not support a high-resolution performance
            # counter
            perf_counter.use_performance_counter = False
    if perf_counter.use_monotonic:
        # The monotonic clock is preferred over the system time
        try:
            return time.monotonic()
        except OSError:
            perf_counter.use_monotonic = False
    return time.time()
perf_counter.use_performance_counter = (os.name == 'nt')
perf_counter.use_monotonic = hasattr(time, 'monotonic')

time.process_time()

当前进程的系统和用户 CPU 时间之和。它不包括睡眠期间经过的时间。它根据定义是进程范围的。返回的值的参考点是未定义的，因此只有连续调用结果之间的差才是有效的。

它在所有平台上都可用。

伪代码 [2]

if os.name == 'nt':
    def process_time():
        handle = _time.GetCurrentProcess()
        process_times = _time.GetProcessTimes(handle)
        return (process_times['UserTime'] + process_times['KernelTime']) * 1e-7
else:
    try:
        import resource
    except ImportError:
        has_resource = False
    else:
        has_resource = True

    def process_time():
        if process_time.clock_id is not None:
            try:
                return time.clock_gettime(process_time.clock_id)
            except OSError:
                process_time.clock_id = None
        if process_time.use_getrusage:
            try:
                usage = resource.getrusage(resource.RUSAGE_SELF)
                return usage[0] + usage[1]
            except OSError:
                process_time.use_getrusage = False
        if process_time.use_times:
            try:
                times = _time.times()
                cpu_time = times.tms_utime + times.tms_stime
                return cpu_time / process_time.ticks_per_seconds
            except OSError:
                process_time.use_getrusage = False
        return _time.clock()
    if (hasattr(time, 'clock_gettime')
        and hasattr(time, 'CLOCK_PROF')):
        process_time.clock_id = time.CLOCK_PROF
    elif (hasattr(time, 'clock_gettime')
          and hasattr(time, 'CLOCK_PROCESS_CPUTIME_ID')):
        process_time.clock_id = time.CLOCK_PROCESS_CPUTIME_ID
    else:
        process_time.clock_id = None
    process_time.use_getrusage = has_resource
    process_time.use_times = hasattr(_time, 'times')
    if process_time.use_times:
        # sysconf("SC_CLK_TCK"), or the HZ constant, or 60
        process_time.ticks_per_seconds = _times.ticks_per_seconds

time.time()

通常是民用时间的系统时间。它根据定义是系统范围的。它可以由系统管理员手动设置，也可以由 NTP 守护程序自动设置。

它在所有平台上都可用，并且不会失败。

伪代码 [2]

if os.name == "nt":
    def time():
        return _time.GetSystemTimeAsFileTime()
else:
    def time():
        if hasattr(time, "clock_gettime"):
            try:
                return time.clock_gettime(time.CLOCK_REALTIME)
            except OSError:
                # CLOCK_REALTIME is not supported (unlikely)
                pass
        if hasattr(_time, "gettimeofday"):
            try:
                return _time.gettimeofday()
            except OSError:
                # gettimeofday() should not fail
                pass
        if hasattr(_time, "ftime"):
            return _time.ftime()
        else:
            return _time.time()

time.sleep()

将执行挂起指定秒数。实际挂起时间可能小于请求的时间，因为任何捕获的信号都将终止 time.sleep()，然后执行该信号的捕获例程。此外，由于系统中其他活动的调度，挂起时间可能会比请求的时间长任意量。

伪代码 [2]

try:
    import select
except ImportError:
    has_select = False
else:
    has_select = hasattr(select, "select")

if has_select:
    def sleep(seconds):
        return select.select([], [], [], seconds)

elif hasattr(_time, "delay"):
    def sleep(seconds):
        milliseconds = int(seconds * 1000)
        _time.delay(milliseconds)

elif os.name == "nt":
    def sleep(seconds):
        milliseconds = int(seconds * 1000)
        win32api.ResetEvent(hInterruptEvent);
        win32api.WaitForSingleObject(sleep.sigint_event, milliseconds)

    sleep.sigint_event = win32api.CreateEvent(NULL, TRUE, FALSE, FALSE)
    # SetEvent(sleep.sigint_event) will be called by the signal handler of SIGINT

elif os.name == "os2":
    def sleep(seconds):
        milliseconds = int(seconds * 1000)
        DosSleep(milliseconds)

else:
    def sleep(seconds):
        seconds = int(seconds)
        _time.sleep(seconds)

time.clock()

在 Unix 上，返回当前处理器时间，以秒为单位的浮点数表示。它根据定义是进程范围的。分辨率，事实上，“处理器时间”的定义本身取决于同名 C 函数，但无论如何，这是用于对 Python 或计时算法进行基准测试的函数。

在 Windows 上，此函数基于 Win32 函数 QueryPerformanceCounter()，返回自第一次调用此函数以来的经过的时钟秒数，以浮点数表示。分辨率通常优于 1 微秒。它是系统范围的。

伪代码 [2]

if os.name == 'nt':
    def clock():
        try:
            return _win_perf_counter()
        except OSError:
            # QueryPerformanceFrequency() fails if the installed
            # hardware does not support a high-resolution performance
            # counter
            pass
        return _time.clock()
else:
    clock = _time.clock

使用标志的一个函数：time.monotonic(fallback=True)

• time.monotonic(fallback=True) 在没有单调时钟可用或单调时钟失败时回退到系统时间。
• time.monotonic(fallback=False) 在单调时钟失败时引发 OSError，如果系统没有提供单调时钟，则引发 NotImplementedError。

在调用者中作为常量传递的关键字参数通常是糟糕的 API。

在 Python 中，为函数引发 NotImplementedError 是不常见的，应避免。

一个 time.monotonic() 函数，无标志

time.monotonic() 返回 (time: float, is_monotonic: bool)。

另一种方法是使用函数属性：time.monotonic.is_monotonic。在第一次调用 time.monotonic() 之前，属性值将为 None。

mach_absolute_time

Mac OS X 提供了一个单调时钟：mach_absolute_time()。它基于系统启动后的绝对经过时间。它不会被调整，也不能被设置。

mach_timebase_info() 提供了一个分数来将时钟值转换为纳秒数。另请参阅 技术问答 QA1398。

mach_absolute_time() 在 PowerPC CPU 上休眠期间停止，但在 Intel CPU 上不会停止：Different behaviour of mach_absolute_time() on i386/ppc。

CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_BOOTTIME

CLOCK_MONOTONIC 和 CLOCK_MONOTONIC_RAW 代表自某个未指定起点以来的单调时间。它们不能被设置。可以使用 clock_getres() 读取分辨率。

文档：参考您操作系统的帮助手册。示例

• FreeBSD clock_gettime() 帮助手册
• Linux clock_gettime() 帮助手册

CLOCK_MONOTONIC 至少在以下操作系统上可用

• DragonFly BSD、FreeBSD >= 5.0、OpenBSD、NetBSD
• Linux
• Solaris

以下操作系统不支持 CLOCK_MONOTONIC

• GNU/Hurd（参见 开放问题/ clock_gettime）
• Mac OS X
• Windows

在 Linux 上，NTP 可能会调整 CLOCK_MONOTONIC 速率（斜坡），但它不能向后跳跃。

CLOCK_MONOTONIC_RAW 是 Linux 特定的。它类似于 CLOCK_MONOTONIC，但提供对不受 NTP 调整影响的原始基于硬件的时间的访问。CLOCK_MONOTONIC_RAW 需要 Linux 2.6.28 或更高版本。

Linux 2.6.39 和 glibc 2.14 引入了一个新的时钟：CLOCK_BOOTTIME。CLOCK_BOOTTIME 与 CLOCK_MONOTONIC 相同，只是它还包括在挂起期间花费的任何时间。另请阅读 Waking systems from suspend（2011 年 3 月）。

CLOCK_MONOTONIC 在机器挂起时停止。

Linux 自 Linux 2.6.32 以来还提供了 CLOCK_MONOTONIC_COARSE。它类似于 CLOCK_MONOTONIC，精度较低，但速度更快。

clock_gettime() 如果系统不支持指定的时钟，即使标准 C 库支持它，也会失败。例如，CLOCK_MONOTONIC_RAW 需要内核版本 2.6.28 或更高版本。

Windows: QueryPerformanceCounter

高分辨率性能计数器。它是单调的。可以使用 QueryPerformanceFrequency() 读取计数器的频率。分辨率为 1 / QueryPerformanceFrequency()。

它具有更高的分辨率，但与 GetTickCount() 和 timeGetTime() 时钟相比，长期精度较低。例如，它会相对于低精度时钟发生漂移。

文档

• MSDN：QueryPerformanceCounter() 文档
• MSDN：QueryPerformanceFrequency() 文档

QueryPerformanceCounter() 使用的硬件时钟

• Windows XP：英特尔处理器的 RDTSC 指令，时钟频率是处理器的频率（在 200 MHz 和 3 GHz 之间，如今通常大于 1 GHz）。
• Windows 2000：ACPI 电源管理计时器，频率 = 3,549,545 Hz。可以通过 boot.ini 中的“/usepmtimer”标志强制执行。

QueryPerformanceFrequency() 应该只调用一次：系统运行期间频率不会改变。如果已安装的硬件不支持高分辨率性能计数器，它将失败。

QueryPerformanceCounter() 不能被调整：SetSystemTimeAdjustment() 只会调整系统时间。

错误

• 性能计数器值可能会因硬件错误而意外跳跃，请参见 KB274323。
• 在 VirtualBox 上，QueryPerformanceCounter() 不会在低位部分溢出时每次递增高位部分，请参见 Monotonic timers（2009 年）。
• VirtualBox 在其虚拟化的 HPET 设备中存在错误：QueryPerformanceCounter() 会向前跳跃大约 42 秒（问题 #8707）。
• Windows XP 存在一个错误（参见 KB896256）：在多处理器计算机上，QueryPerformanceCounter() 返回每个处理器的不同值。该错误在 Windows XP SP2 中已修复。
• 具有可变频率的处理器的问题：频率会根据工作负载更改以减少内存消耗。
• Chromium 在 Athlon X2 CPU（型号 15）上不使用 QueryPerformanceCounter()，因为“QueryPerformanceCounter 不可靠”（参见 Chromium 源代码中的 base/time_win.cc）

Windows: GetTickCount(), GetTickCount64()

GetTickCount() 和 GetTickCount64() 是单调的，不会失败，也不会被 SetSystemTimeAdjustment() 调整。MSDN 文档：GetTickCount()，GetTickCount64()。分辨率可以使用 GetSystemTimeAdjustment() 读取。

通过 GetTickCount() 或 GetTickCount64() 获取的经过时间包括系统在睡眠或休眠状态下花费的时间。

GetTickCount64() 已添加到 Windows Vista 和 Windows Server 2008。

可以使用 未公开的 NtSetTimerResolution() 函数 来提高精度。有一些应用程序使用此未公开的函数，例如：计时器分辨率。

WaitForSingleObject() 使用与 GetTickCount() 相同的计时器，精度相同。

Windows: timeGetTime

timeGetTime 函数以毫秒为单位检索系统时间。系统时间是 Windows 启动后经过的时间。阅读 timeGetTime() 文档。

timeGetTime() 的返回类型是 32 位无符号整数。与 GetTickCount() 一样，timeGetTime() 在 2^32 毫秒（49.7 天）后会回滚。

通过 timeGetTime() 获取的经过时间包括系统在睡眠状态下花费的时间。

timeGetTime 函数的默认精度可以是 5 毫秒或更多，具体取决于机器。

timeBeginPeriod() 可用于将 timeGetTime() 的精度提高到 1 毫秒，但这会对功耗产生负面影响。调用 timeBeginPeriod() 还会影响其他一些计时调用的粒度，例如 CreateWaitableTimer()、WaitForSingleObject() 和 Sleep()。

Solaris: CLOCK_HIGHRES

Solaris OS 具有一个 CLOCK_HIGHRES 计时器，该计时器尝试使用最佳硬件源，并且可能提供接近纳秒级的分辨率。CLOCK_HIGHRES 是不可调整的高分辨率时钟。对于使用 clockid_t 值为 CLOCK_HIGHRES 创建的计时器，系统将尝试使用最佳硬件源。

CLOCK_HIGHRES 的分辨率可以使用 clock_getres() 读取。

Solaris: gethrtime

gethrtime() 函数返回当前高分辨率实时。时间表示为从过去某个任意时间起的纳秒数；它与当天的时间没有任何关联，因此不会通过 adjtime() 或 settimeofday() 受到重置或漂移的影响。hires 计时器非常适合性能测量任务，在这种任务中需要廉价且准确的间隔计时。

gethrtime() 的线性在挂起-恢复周期中不会保留（错误 4272663）。

阅读 Solaris 11 的 gethrtime() 手册页。

在 Solaris 上，gethrtime() 与 clock_gettime(CLOCK_MONOTONIC) 相同。

Windows: GetSystemTimeAsFileTime

可以使用 GetSystemTimeAsFileTime()、ftime() 和 time() 读取系统时间。系统时间的分辨率可以使用 GetSystemTimeAdjustment() 读取。

阅读 GetSystemTimeAsFileTime() 文档。

可以使用 SetSystemTime() 设置系统时间。

UNIX 上的系统时间

gettimeofday()、ftime()、time() 和 clock_gettime(CLOCK_REALTIME) 返回系统时间。CLOCK_REALTIME 的分辨率可以使用 clock_getres() 读取。

可以使用 settimeofday() 或 clock_settime(CLOCK_REALTIME) 设置系统时间。

自 Linux 2.6.32 起，Linux 还提供 CLOCK_REALTIME_COARSE。它类似于 CLOCK_REALTIME，精度较低，但速度更快。

Alexander Shishkin 提出了一种用于 Linux 的 API，以便在系统时钟更改时收到通知：timerfd：添加 TFD_NOTIFY_CLOCK_SET 来监视时钟更改（API 的第 4 个版本，2011 年 3 月）。该 API 尚未被接受，但 CLOCK_BOOTTIME 提供了类似的功能。

函数

• Windows：GetProcessTimes()。分辨率可以使用 GetSystemTimeAdjustment() 读取。
• clock_gettime(CLOCK_PROCESS_CPUTIME_ID)：来自 CPU 的高分辨率每进程计时器。分辨率可以使用 clock_getres() 读取。
• clock()。分辨率为 1 / CLOCKS_PER_SEC。
  • Windows：自进程启动以来的经过挂钟时间（以秒为单位的经过时间乘以 CLOCKS_PER_SEC）。包括睡眠期间的经过时间。它可能失败。
  • UNIX：返回程序使用的处理器时间的近似值。
• getrusage(RUSAGE_SELF) 返回当前进程的资源使用情况结构。ru_utime 是用户 CPU 时间，ru_stime 是系统 CPU 时间。
• times()：进程时间结构。分辨率为 1 / ticks_per_seconds，其中 ticks_per_seconds 是 sysconf(_SC_CLK_TCK) 或 HZ 常量。

Python 源代码包含一个便携式库来获取进程时间（CPU 时间）：Tools/pybench/systimes.py。

另请参见 QueryProcessCycleTime() 函数（所有线程的循环时间的总和）和 clock_getcpuclockid()。

函数

• Windows：GetThreadTimes()。分辨率可以使用 GetSystemTimeAdjustment() 读取。
• clock_gettime(CLOCK_THREAD_CPUTIME_ID)：线程特定的 CPU 时间时钟。它使用 CPU 周期的数量，而不是秒的数量。分辨率可以使用 clock_getres() 读取。

另请参见 QueryThreadCycleTime() 函数（指定线程的循环时间）和 pthread_getcpuclockid()。

函数

• sleep(seconds)
• usleep(microseconds)
• nanosleep(nanoseconds, remaining): Linux 的 nanosleep() 手册页
• delay(milliseconds)

clock_nanosleep

clock_nanosleep(clock_id, flags, nanoseconds, remaining): Linux 的 clock_nanosleep() 手册页。

如果 flags 是 TIMER_ABSTIME，则请求将被解释为由时钟 clock_id 测量的绝对时间。如果请求小于或等于时钟的当前值，则 clock_nanosleep() 会立即返回，而不会挂起调用线程。

POSIX.1 指定，通过 clock_settime(2) 更改 CLOCK_REALTIME 时钟的值，对阻塞在相对 clock_nanosleep() 上的线程没有影响。

select()

select(nfds, readfds, writefds, exceptfs, timeout)。

自 Linux 2.6.28 起，select() 使用高分辨率计时器来处理超时。进程具有一个“松弛”属性来配置超时的精度，默认松弛为 50 微秒。在 Linux 2.6.28 之前，select() 的超时由主计时子系统以 jiffy 级分辨率处理。另请阅读 高（但不太高）分辨率超时 和 计时器松弛。

其他函数

• poll()、epoll()
• sigtimedwait()。POSIX：“如果支持单调时钟选项，则应使用 CLOCK_MONOTONIC 时钟来测量由 timeout 参数指定的时间间隔。”
• pthread_cond_timedwait()、pthread_condattr_setclock()。“时钟属性的默认值应引用系统时间。”
• sem_timedwait()：“如果支持计时器选项，则超时应基于 CLOCK_REALTIME 时钟。如果不支持计时器选项，则超时应基于 time() 函数返回的系统时间。超时的精度应为其基于的时钟的精度。”
• WaitForSingleObject()：使用与 GetTickCount() 相同的计时器，精度相同。