为何time.sleep参数会影响非依赖代码的执行时长？

现象描述 #

运行以下多进程代码时，即使time.sleep位于测量的工作代码块之外，调整SLEEP_TIME（如0、1ms、10ms）或完全移除睡眠语句，都会导致工作部分的平均执行时长出现明显波动：

import numpy as np
import multiprocessing 
import time

SLEEP_TIME = 1e-3

def do_work():
    total_time = 0
    time_to_run = 500
    for i in range(time_to_run):
        t0 = time.time()
        
        # 核心工作代码
        nparr = np.ones((1000,100,30))
        nparr[nparr == 0] = 1
        sp = nparr.shape # 确保前序操作完成
        # 工作代码结束
        
        t1 = time.time()                
        total_time += t1 - t0        
        time.sleep(SLEEP_TIME) # 该语句不在测量范围内，但影响工作时长
    
    print(f"avg work time: {1000 * total_time / time_to_run:.2f}ms")        

if __name__ == '__main__':
    p1 = multiprocessing.Process(target=do_work)        
    p1.start()
    p2 = multiprocessing.Process(target=do_work)        
    p2.start()

    p1.join()
    p2.join()

Linux下测试结果示例：

• 无睡眠（注释time.sleep）：avg work time: 4.50ms、4.56ms
• SLEEP_TIME = 0：avg work time: 4.46ms、4.52ms
• SLEEP_TIME = 1e-3：avg work time: 4.76ms、4.82ms
• SLEEP_TIME = 10e-3：avg work time: 7.05ms、7.07ms

Windows下也有类似现象，且完全移除睡眠时性能下降更明显。即使添加os.environ["OMP_NUM_THREADS"] = "1"限制Numpy线程数，仍存在执行时长差异。

原因分析 #

1. 操作系统调度与CPU缓存失效 #

当进程调用time.sleep（尤其是非零时长），会主动放弃CPU时间片，操作系统会将CPU资源分配给其他进程。当睡眠结束进程被重新调度时：

• CPU的L1/L2/L3缓存可能已被其他进程占用，工作代码需要重新加载数据到缓存，导致缓存失效延迟；
• 部分CPU核心可能因空闲进入低功耗状态（如降频），重新唤醒需要时间恢复到高性能模式，增加执行延迟。

而无睡眠时，进程持续占用CPU，缓存保持"热状态"，数据无需重新加载，执行速度更稳定。

2. 内存页交换与带宽争用 #

工作代码创建的大Numpy数组会占用大量内存页：

• 当进程睡眠时长较长时，操作系统可能将闲置的内存页换出到磁盘（虚拟内存），进程唤醒后需要从磁盘重新加载这些页，导致磁盘IO延迟；
• 多进程同时运行时，睡眠会改变进程的调度频率，间接影响内存带宽的分配，进而影响数组操作的执行速度。

3. Numpy底层多线程的隐性竞争 #

Numpy依赖OpenBLAS/MKL等底层库实现并行计算，这些库会自动启用多线程。即使设置OMP_NUM_THREADS=1，进程间的CPU核心竞争、调度器的优先级调整，依然会因睡眠行为的变化而改变，导致执行时长波动。

解决方案 #

1. 禁用CPU频率缩放 #

• Linux：执行cpupower frequency-set -g performance，强制CPU保持最高频率，避免因空闲降频带来的唤醒延迟；
• Windows：在电源选项中切换到"高性能"模式。

2. 预热CPU与内存缓存 #

在循环开始前，先执行一次工作代码，让相关数据加载到CPU缓存和物理内存中，后续循环的执行时间会更稳定：

def do_work():
    # 预热缓存
    nparr = np.ones((1000,100,30))
    nparr[nparr == 0] = 1
    sp = nparr.shape
    
    total_time = 0
    time_to_run = 500
    for i in range(time_to_run):
        # 原有工作代码与计时逻辑...

3. 绑定进程到固定CPU核心 #

通过CPU亲和性设置，将每个进程绑定到单独的核心，避免进程在核心间切换导致的缓存失效：

import os
def do_work():
    # 绑定当前进程到核心0（根据实际CPU核心数调整）
    os.sched_setaffinity(0, {0})
    # 原有工作代码...

Windows下可使用win32process.SetProcessAffinityMask实现类似功能。

4. 移除不必要的睡眠 #

如果不需要等待外部资源，直接移除time.sleep语句，让进程持续运行，保持缓存热状态，这是让工作代码速度最快且稳定的最优方案。

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