C/C++中如何实现每秒固定调用N次函数且补偿时间漂移？

传统sleep方案的缺陷 #

你提到的末尾加固定sleep、或者根据函数耗时补sleep的方案，核心问题是用相对时间做休眠基准，每次休眠的起始点是上一次函数执行结束的时间，函数执行耗时的波动、系统调度的延迟都会产生累计误差，运行时间越长漂移越明显，完全达不到你要求的M秒后总调用次数恰好为N*M的需求。

最优实现思路 #

要完全避免漂移，核心是用绝对时间戳作为全局基准，所有调用的目标时间点都和初始启动时间绑定，第k次调用的目标时间为启动时间 + k * (1/N)秒，不受单次函数执行耗时、调度延迟的影响，只要函数平均执行耗时小于1/N秒，累计调用次数就永远精准对齐，不会产生漂移。

你提到的硬件高精度定时器（HPET、APIC定时器等）已经被操作系统封装为用户态可用的高精度时钟接口，不需要直接操作硬件或处理中断，调用系统提供的定时接口即可获得微秒到纳秒级的定时精度。

代码实现 #

C++11 跨平台实现（推荐） #

C++11引入的std::chrono库提供了跨平台的单调时钟和绝对时间休眠接口，主流Windows、Linux平台的实现精度都能满足物理引擎等场景的需求：

#include <chrono>
#include <thread>
#include <iostream>

// 自定义业务函数
void foo() {
    static int call_count = 0;
    call_count++;
    // 此处添加你的逻辑，比如物理引擎更新
}

int main() {
    using namespace std::chrono;
    const int CALLS_PER_SECOND = 60; // 每秒调用次数N，可自行修改
    const auto interval = nanoseconds(1000000000 / CALLS_PER_SECOND);

    // 用单调时钟做基准，不受系统时间修改影响
    auto next_call_time = steady_clock::now();

    // 运行M秒示例，这里以运行10秒为例，可替换为你自己的退出条件
    const int RUN_DURATION_SEC = 10;
    auto end_time = next_call_time + seconds(RUN_DURATION_SEC);

    while (steady_clock::now() < end_time) {
        foo();
        next_call_time += interval;
        // 休眠到下一个绝对目标时间点，不会产生累计误差
        std::this_thread::sleep_until(next_call_time);
    }

    return 0;
}

Linux 原生C实现 #

如果需要更底层的控制，可以使用Linux提供的clock_nanosleep接口，支持纳秒级绝对时间休眠，精度更高：

#include <time.h>
#include <stdio.h>
#include <stdbool.h>

void foo() {
    static int call_count = 0;
    call_count++;
    // 业务逻辑
}

int main() {
    const int CALLS_PER_SECOND = 1000; // 每秒调用次数N
    const long INTERVAL_NS = 1000000000L / CALLS_PER_SECOND;
    const int RUN_DURATION_SEC = 10; // 运行时长M秒

    struct timespec next_call;
    clock_gettime(CLOCK_MONOTONIC, &next_call);
    struct timespec end_time = next_call;
    end_time.tv_sec += RUN_DURATION_SEC;

    while (true) {
        // 检查是否到达运行结束时间
        struct timespec now;
        clock_gettime(CLOCK_MONOTONIC, &now);
        if (now.tv_sec > end_time.tv_sec || (now.tv_sec == end_time.tv_sec && now.tv_nsec >= end_time.tv_nsec)) {
            break;
        }

        foo();

        // 计算下一次调用的绝对时间
        next_call.tv_nsec += INTERVAL_NS;
        if (next_call.tv_nsec >= 1000000000L) {
            next_call.tv_sec += 1;
            next_call.tv_nsec -= 1000000000L;
        }

        // 绝对时间休眠，即使被信号打断也不会产生误差
        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next_call, NULL);
    }

    return 0;
}

注意事项 #

• 必须使用单调时钟（std::steady_clock/CLOCK_MONOTONIC）作为时间基准，不要使用系统实时时钟，避免系统时间被修改导致定时异常
• 如果单次foo执行耗时偶尔超过调用间隔，程序会跳过休眠直接执行下一次调用，自动追赶进度，只要平均耗时小于间隔，累计调用次数始终精准
• 如需进一步降低唤醒延迟，可以将定时线程绑定到固定CPU核心，并设置高调度优先级

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