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

• • 日程安排基础**

放弃CPU然后再重新获得它是昂贵的。根据this article，Linux上的调度器延迟可能在10 - 30ms之间。所以如果你需要高精度地睡眠少于10ms，那么你需要使用特殊的操作系统特定的API。通常的C++11 std：：this_thread：：sleep_for不是高分辨率睡眠。例如，在我的机器上，快速测试显示，当我要求它睡眠1ms时，它通常睡眠至少3ms。

• • Linux**

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

• • Windows**

这里的解决方案是像其他人建议的那样使用多媒体时间。如果你想在Windows上模拟Linux的nanosleep（），下面是如何（original ref）。再次注意，如果你在循环中调用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;
}

• • 跨平台代码**

这是time_util.cc，它实现了Linux的睡眠，Windows和苹果的平台。但是请注意，它没有像我上面提到的那样使用sched_setscheduler设置实时模式，所以如果你想使用〈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头文件以及其他东西，如果你正在开发只有头文件的库，这可能不是很理想。如果你需要睡眠少于2ms，并且你不是很热衷于使用操作系统代码，那么你可以只使用下面的简单解决方案，这是跨平台的，在我的测试中效果很好。请记住，您现在没有使用经过大量优化的操作系统代码，这些代码在节省电源和管理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);
    }
}

• • 相关问题**
• How to make thread sleep less than a millisecond on Windows
• Cross platform Sleep function for C++
• Is there an alternative sleep function in C to milliseconds?

这里不要使用旋转。要求的分辨率和精度可以用标准方法达到。
当系统中断周期被设置为以如此高的频率运行时，您可以使用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()延迟取决于系统硬件。（由多媒体定时器API设置）。这对应于0.9765625 ms的周期。因此，您可以获得的最接近值为4.8828125 ms。其他值允许更接近，特别是自Windows 7以来，当在提供high resolution event timers的硬件上操作时，计时已经显著改善。请参见MSDN上的About Timers和High Precision Event Timer。

**摘要：**将多媒体定时器设置为以最高频率工作并使用waitable timer。

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

也许你可以尝试一个循环来检查时间间隔，并在时间差为5ms时返回，而不是使用sleep。循环应该比sleep更精确。
然而，要知道精确并不总是可能的，cpu可能会在这么短的时间间隔内被另一个操作占用，从而可能错过5 ms。

这些职能：

• CreateWaitableTimer
• SetWaitableTimer
• WaitForSingleObject

允许您创建一个分辨率为100纳秒的可等待计时器，等待它，并让调用线程在触发时执行特定函数。
Here's an example of use of said timer.
注意，WaitForSingleObject有一个以毫秒为单位的超时，这也许可以作为等待的一个粗略的替代，但我不相信它，有关详细信息，请参见SO question。

如果你想要精确度，并且你有管理员权限，在linux上你可以通过read（）调用设置时钟芯片进行轮询。操作系统将阻塞，直到下一个信号从芯片进来（中断）。我在访问二级rtc时成功地使用了这个方法，比如“/dev/rtc 2”。它也没有消耗额外的功率。
在Windows上，您可以创建一个用户模式驱动程序来完成相同的任务。或者，QueryPerformanceCounter（）是高分辨率计时器，建议您使用它而不是“rdtsc”汇编指令。