休眠几毫秒

Question

我知道 POSIX sleep(x) 函数使程序休眠 x 秒。 C++ 中是否有一个函数可以让程序休眠 x 毫秒？

Answer 1

在 C++11 中，您可以使用标准库工具来完成此操作：

#include <chrono>
#include <thread>

std::this_thread::sleep_for(std::chrono::milliseconds(x));

清晰易读，不再需要猜测 sleep() 函数采用的单位。

Answer 2

请注意，没有针对毫秒的标准 C API，因此（在 Unix 上）您将不得不使用 usleep，它接受微秒：

#include <unistd.h>

unsigned int microseconds;
...
usleep(microseconds);

Answer 3

为了保持便携性，您可以使用 Boost::Thread睡觉：

#include <boost/thread/thread.hpp>

int main()
{
    //waits 2 seconds
    boost::this_thread::sleep( boost::posix_time::seconds(1) );
    boost::this_thread::sleep( boost::posix_time::milliseconds(1000) );

    return 0;
}

这个答案是重复的，并已发布在此问题< /a> 之前。也许您也可以在那里找到一些有用的答案。

Answer 4

在 Unix 中，您可以使用 usleep。

在 Windows 中，有 睡眠< /a>.

Answer 5

从 C++14 开始，使用 std 及其数字文字：

#include <chrono>
#include <thread>

using namespace std::chrono_literals;

std::this_thread::sleep_for(123ms);

Answer 6

根据您的平台，您可能有 usleep 或 nanosleep 可用。 usleep 已弃用，并已从最新的 POSIX 标准中删除； nanosleep 是首选。

Answer 7

为什么不使用 time.h 库？在 Windows 和 POSIX 系统上运行（不要在生产中使用此代码！）：

CPU 保持 IDLE 状态：

#include <iostream>
#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
#endif // _WIN32

using namespace std;

void sleepcp(int milliseconds);

void sleepcp(int milliseconds) // Cross-platform sleep function
{
    #ifdef _WIN32
        Sleep(milliseconds);
    #else
        usleep(milliseconds * 1000);
    #endif // _WIN32
}
int main()
{
    cout << "Hi! At the count to 3, I'll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

Answer 8

nanosleep 是比 usleep 更好的选择 - 它对中断更具弹性。

Answer 9

#include <windows.h>

语法：

Sleep (  __in DWORD dwMilliseconds   );

用法：

Sleep (1000); //Sleeps for 1000 ms or 1 sec

Answer 10

如果使用 MS Visual C++ 10.0，您可以使用标准库工具来完成此操作：

Concurrency::wait(milliseconds);

您将需要：

#include <concrt.h>

Answer 11

在具有 select 功能的平台（POSIX、Linux 和 Windows）上，您可以这样做：

void sleep(unsigned long msec) {
    timeval delay = {msec / 1000, msec % 1000 * 1000};
    int rc = ::select(0, NULL, NULL, NULL, &delay);
    if(-1 == rc) {
        // Handle signals by continuing to sleep or return immediately.
    }
}

但是，现在有更好的替代方案。

Answer 12

Select 调用是一种更精确的方法（睡眠时间可以以纳秒为单位指定）。

Answer 13

在 C++ 中让程序休眠的方法是 Sleep(int) 方法。它的头文件是#include "windows.h."

例如：

#include "stdafx.h"
#include "windows.h"
#include "iostream"
using namespace std;

int main()
{
    int x = 6000;
    Sleep(x);
    cout << "6 seconds have passed" << endl;
    return 0;
}

它的睡眠时间以毫秒为单位，没有限制。

Second = 1000 milliseconds
Minute = 60000 milliseconds
Hour = 3600000 milliseconds

Answer 14

C++14：休眠 10 秒：

#include <thread>
#include <chrono>

using namespace std::chrono_literals;
std::this_thread::sleep_for(10s);

10 毫秒使用 10ms

Answer 15

使用Boost异步输入/输出线程，休眠x毫秒；

#include <boost/thread.hpp>
#include <boost/asio.hpp>

boost::thread::sleep(boost::get_system_time() + boost::posix_time::millisec(1000));

Answer 16

来自一个答案的优雅解决方案，经过一点修改。如果没有更好的功能可用，可以轻松添加 select() 用法。只需制作使用 select() 等的函数即可。

代码：

#include <iostream>

/*
 Prepare defines for millisecond sleep function that is cross-platform
*/
#ifdef _WIN32
#  include <Windows.h>
#  define sleep_function_name           Sleep
#  define sleep_time_multiplier_for_ms      1
#else
#  include <unistd.h>
#  define sleep_function_name           usleep
#  define sleep_time_multiplier_for_ms      1000
#endif

/* Cross platform millisecond sleep */
void cross_platform_sleep_ms(unsigned long int time_to_sleep_in_ms)
{
   sleep_function_name ( sleep_time_multiplier_for_ms * time_to_sleep_in_ms );
}

Answer 17

作为 POSIX 系统的 Win32 替代品：

void Sleep(unsigned int milliseconds) {
    usleep(milliseconds * 1000);
}

while (1) {
    printf(".");
    Sleep((unsigned int)(1000.0f/20.0f)); // 20 fps
}

Answer 18

这个问题很老了，但我设法找到了一种简单的方法来将其添加到我的应用程序中。您可以创建一个 C/C++ 宏，如下所示使用它：

#ifndef MACROS_H
#define MACROS_H

#include <unistd.h>

#define msleep(X) usleep(X * 1000)

#endif // MACROS_H

Answer 19

我用这个：

#include <thread>
#define sleepms(val) std::this_thread::sleep_for(val##ms)

示例：

sleepms(200);