Python中time.sleep()精度问题及高精度休眠替代方案问询

我在Python 3.12中测试time.sleep()精度时，编写了两个线程函数：

• loop_1每次执行后调用sleep(0.01)
• loop_2每次执行后调用sleep(0.0000001)

统计每秒执行次数（pps）后发现二者结果几乎一致，说明time.sleep()实际精度仅能达到百分之一秒。

我尝试了以下优化写法：

def loop_2():
    global nl_2
    sleep_time = 0.0001
    max_acc = 0.01
    while True:
        if sleep_time < max_acc:
            for i in range(int(max_acc / sleep_time)):
                nl_2 += 1
            sleep(max_acc)
        else:
            nl_2 += 1
            sleep(sleep_time)

但该方案的精度表现因操作系统而异，现寻求适配当前系统的高精度休眠替代方案。

分系统高精度休眠解决方案 #

1. 通用忙等待方案（微秒级精度，注意CPU占用） #

如果需要短时间（如小于1ms）的高精度休眠，可借助time.perf_counter()实现忙等待，避免系统调用的延迟：

import time

def high_precision_sleep_short(seconds):
    start = time.perf_counter()
    while time.perf_counter() - start < seconds:
        pass

提示：该方式会持续占用单个CPU核心，仅适合微秒级短休眠，长时间休眠不建议使用。

2. Windows平台：调用系统API实现高精度休眠 #

Windows下可通过ctypes直接调用SleepEx函数，利用系统的高精度计时器：

import ctypes
kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)

def win_high_precision_sleep(seconds):
    # 转换为100纳秒单位（Windows系统计时器基准）
    interval = int(seconds * 10_000_000)
    kernel32.SleepEx(interval, False)

3. Linux平台：使用nanosleep系统调用 #

Linux下nanosleep是专门的高精度休眠接口，阻塞式且精度远高于time.sleep()，通过ctypes调用：

import ctypes
import ctypes.util

libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)

class timespec(ctypes.Structure):
    _fields_ = [('tv_sec', ctypes.c_long), ('tv_nsec', ctypes.c_long)]

def linux_high_precision_sleep(seconds):
    sec = int(seconds)
    nsec = int((seconds - sec) * 1_000_000_000)
    req = timespec(sec, nsec)
    rem = timespec(0, 0)
    # 处理被信号中断的情况，重新休眠剩余时间
    while libc.nanosleep(ctypes.byref(req), ctypes.byref(rem)) == -1:
        req = rem

4. macOS平台：调用Mach内核接口 #

macOS下可使用mach_wait_until直接基于系统高精度计时器实现纳秒级休眠：

import ctypes
import time

libmach = ctypes.CDLL('/usr/lib/libmach.dylib', use_errno=True)

def mac_high_precision_sleep(seconds):
    deadline = time.perf_counter_ns() + int(seconds * 1_000_000_000)
    libmach.mach_wait_until(deadline)

自动适配系统的封装方案 #

可以封装一个函数，根据当前操作系统和休眠时长自动选择最优方案：

import sys
import time
import ctypes

def high_precision_sleep(seconds):
    if seconds <= 0:
        return
    
    # 短休眠用忙等待保证精度，长休眠用系统API降低CPU占用
    if seconds < 0.001:
        start = time.perf_counter()
        while time.perf_counter() - start < seconds:
            pass
        return
    
    if sys.platform.startswith('win'):
        kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
        interval = int(seconds * 10_000_000)
        kernel32.SleepEx(interval, False)
    elif sys.platform.startswith('linux'):
        libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)
        class timespec(ctypes.Structure):
            _fields_ = [('tv_sec', ctypes.c_long), ('tv_nsec', ctypes.c_long)]
        sec = int(seconds)
        nsec = int((seconds - sec) * 1_000_000_000)
        req = timespec(sec, nsec)
        rem = timespec(0, 0)
        while libc.nanosleep(ctypes.byref(req), ctypes.byref(rem)) == -1:
            req = rem
    elif sys.platform.startswith('darwin'):
        libmach = ctypes.CDLL('/usr/lib/libmach.dylib', use_errno=True)
        deadline = time.perf_counter_ns() + int(seconds * 1_000_000_000)
        libmach.mach_wait_until(deadline)
    else:
        # 未知系统 fallback 到原生time.sleep
        time.sleep(seconds)

内容的提问来源于stack exchange，提问作者radin