Question

我有运行循环的线程。我需要每5ms运行一次循环（1ms错误）。我知道Sleep（）函数不精确。

你有什么建议吗？

更新。我不能以其他方式做到这一点。在循环结束时，我需要某种睡眠。我也不想加载100％的CPU。

Answer 1

不要在这里使用纺纱。使用标准方法可以达到要求的分辨率和准确度。

当系统中断周期设置为以该高频率工作时，您可以使用Sleep()向下约1 ms的周期。查看description of Sleep()以获取详细信息，特别是multimedia timers和Obtaining and Setting Timer Resolution，以获取有关如何设置系统中断周期的详细信息。使用这种方法可获得的准确度在正确实施时在几微秒范围内。

我怀疑你的循环也在做其他事情。因此，我怀疑你想要一个5毫秒的总时间，然后是Sleep()和你在循环中花在其他东西上的其余时间的总和。

对于这种情况，我建议Waitable Timer Objects，但是，这些计时器也依赖于多媒体计时器API的设置。我已经概述了相关函数的更高精度时序here。可以找到关于高精度时序的更深入的见解here。

要获得更加准确和可靠的时间安排，您可能需要查看process priority classes和thread priorities。关于Sleep（）准确性的另一个答案是this。

但是，是否有可能获得精确5 ms的Sleep()延迟取决于系统硬件。某些系统允许您以每秒1024个中断运行（由多媒体计时器API设置）。这相当于0.9765625毫秒的周期。因此，您最接近的是4.8828125 ms。其他人允许更接近，特别是自Windows 7以来，在提供high resolution event timers的硬件上运行时，时间显着改善。请参阅MSDN上的About Timers和High Precision Event Timer。

摘要：将多媒体计时器设置为以最高频率运行，然后使用waitable timer。

Answer 2

我一直在寻找适合实时应用的轻量级跨平台睡眠功能（即高分辨率/高精度和可靠性）。以下是我的发现：

安排基础知识

放弃CPU然后将其取回昂贵。根据{{3}}，Linux上的调度程序延迟可能在10到30毫秒之间。因此，如果您需要以高精度睡眠不到10毫秒，那么您需要使用特殊的操作系统特定API。通常的C ++ 11 std :: this_thread :: sleep_for不是高分辨率睡眠。例如，在我的机器上，快速测试表明，当我要求它只睡1分钟时，它经常会睡3个小时。

<强>的Linux

最流行的解决方案似乎是nanosleep（）API。但是如果你想要＆lt; 2ms睡眠时的分辨率高于你需要使用sched_setscheduler调用来设置线程/进程进行实时调度。如果你不是nanosleep（）就像过时的usleep一样，其分辨率约为10ms。另一种可能性是使用this article。

<强>窗

此处的解决方案是使用其他人建议的多媒体时间。如果你想在Windows上模仿Linux的nanosleep（），下面是如何（alarms）。同样，请注意，如果您在循环中调用sleep（），则不需要反复执行CreateWaitableTimer（）。

#include <windows.h>    /* WinAPI */

/* Windows sleep in 100ns units */
BOOLEAN nanosleep(LONGLONG ns){
    /* Declarations */
    HANDLE timer;   /* Timer handle */
    LARGE_INTEGER li;   /* Time defintion */
    /* Create timer */
    if(!(timer = CreateWaitableTimer(NULL, TRUE, NULL)))
        return FALSE;
    /* Set timer properties */
    li.QuadPart = -ns;
    if(!SetWaitableTimer(timer, &li, 0, NULL, NULL, FALSE)){
        CloseHandle(timer);
        return FALSE;
    }
    /* Start & wait for timer */
    WaitForSingleObject(timer, INFINITE);
    /* Clean resources */
    CloseHandle(timer);
    /* Slept without problems */
    return TRUE;
}

跨平台代码

这是original ref为Linux，Windows和Apple平台实现睡眠的time_util.cc。但是请注意，它没有像我上面提到的那样使用sched_setscheduler设置实时模式，所以如果你想使用＆lt; 2ms那么你需要另外做的事情。您可以做的另一项改进是，如果您在某个循环中调用sleep，则应避免一遍又一遍地调用CreateWaitableTimer for Windows版本。有关如何执行此操作，请参阅example here。

#include "time_util.h"

#ifdef _WIN32
#  define WIN32_LEAN_AND_MEAN
#  include <windows.h>

#else
#  include <time.h>
#  include <errno.h>

#  ifdef __APPLE__
#    include <mach/clock.h>
#    include <mach/mach.h>
#  endif
#endif // _WIN32

/**********************************=> unix ************************************/
#ifndef _WIN32
void SleepInMs(uint32 ms) {
    struct timespec ts;
    ts.tv_sec = ms / 1000;
    ts.tv_nsec = ms % 1000 * 1000000;

    while (nanosleep(&ts, &ts) == -1 && errno == EINTR);
}

void SleepInUs(uint32 us) {
    struct timespec ts;
    ts.tv_sec = us / 1000000;
    ts.tv_nsec = us % 1000000 * 1000;

    while (nanosleep(&ts, &ts) == -1 && errno == EINTR);
}

#ifndef __APPLE__
uint64 NowInUs() {
    struct timespec now;
    clock_gettime(CLOCK_MONOTONIC, &now);
    return static_cast<uint64>(now.tv_sec) * 1000000 + now.tv_nsec / 1000;
}

#else // mac
uint64 NowInUs() {
    clock_serv_t cs;
    mach_timespec_t ts;

    host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cs);
    clock_get_time(cs, &ts);
    mach_port_deallocate(mach_task_self(), cs);

    return static_cast<uint64>(ts.tv_sec) * 1000000 + ts.tv_nsec / 1000;
}
#endif // __APPLE__
#endif // _WIN32
/************************************ unix <=**********************************/

/**********************************=> win *************************************/
#ifdef _WIN32
void SleepInMs(uint32 ms) {
    ::Sleep(ms);
}

void SleepInUs(uint32 us) {
    ::LARGE_INTEGER ft;
    ft.QuadPart = -static_cast<int64>(us * 10);  // '-' using relative time

    ::HANDLE timer = ::CreateWaitableTimer(NULL, TRUE, NULL);
    ::SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);
    ::WaitForSingleObject(timer, INFINITE);
    ::CloseHandle(timer);
}

static inline uint64 GetPerfFrequency() {
    ::LARGE_INTEGER freq;
    ::QueryPerformanceFrequency(&freq);
    return freq.QuadPart;
}

static inline uint64 PerfFrequency() {
    static uint64 xFreq = GetPerfFrequency();
    return xFreq;
}

static inline uint64 PerfCounter() {
    ::LARGE_INTEGER counter;
    ::QueryPerformanceCounter(&counter);
    return counter.QuadPart;
}

uint64 NowInUs() {
    return static_cast<uint64>(
        static_cast<double>(PerfCounter()) * 1000000 / PerfFrequency());
}
#endif // _WIN32

另一个更完整的跨平台代码可以是found here。

另一个快速解决方案

正如您可能已经注意到的，上面的代码不再是非常轻量级的。它需要包括Windows标题，如果您正在开发仅标题库，那么可能不太理想。如果您需要睡眠时间少于2毫秒并且您不是非常热衷于使用操作系统代码，那么您可以使用以下简单的解决方案，这是跨平台的，并且在我的测试中运行良好。请记住，您现在没有使用经过大量优化的操作系统代码，这可能会更好地节省电源和管理CPU资源。

typedef std::chrono::high_resolution_clock clock;
template <typename T>
using duration = std::chrono::duration<T>;

static void sleep_for(double dt)
{
    static constexpr duration<double> MinSleepDuration(0);
    clock::time_point start = clock::now();
    while (duration<double>(clock::now() - start).count() < dt) {
        std::this_thread::sleep_for(MinSleepDuration);
    }
}

相关问题

Answer 3

从问题标签我想你是在Windows上。看看Multimedia Timers，他们宣传精度低于1毫秒。另一个选择是使用Spin Locks，但这基本上会使cpu核心保持最大使用率。

Answer 4

或许，您可以尝试使用循环来检查时间间隔，并在时差为5毫秒时返回。循环应该比睡眠更准确。

但是，请注意精确度并非总是如此。 cpu可以与另一个操作绑定这么小的间隔，可能会错过5毫秒。

Answer 5

这些功能：

让你创建一个具有100纳秒分辨率的等待计时器，等待它，并让调用线程在触发时执行特定的功能。

Here's an example of use of said timer

请注意，WaitForSingleObject具有以毫秒为单位的超时，这可能可以作为等待的粗略替代，但我不相信它。有关详细信息，请参阅此SO question。

需要精确的线程睡眠。最大1ms错误

5 个答案: