Спать в течение миллисекунд

381

Я знаю, что функция POSIX sleep(x) делает программу спящей в течение x секунд. Есть ли функция, позволяющая программе спящий режим для x миллисекунд в С++?

  • 6
    Вы должны знать, что в Windows в любом случае Sleep() имеет точность в миллисекунды, но ее точность может быть на несколько порядков выше. Вы можете думать, что спите 4 миллисекунды, но на самом деле спите 400.
  • 5
    @John Dibling: Я думаю, что он использует sleep POSIX, а не win32 Sleep учетом «х секунд».
Показать ещё 2 комментария
Теги:
sleep

14 ответов

336
Лучший ответ

Обратите внимание, что нет стандартного API C для миллисекунд, поэтому (в Unix) вам придется рассчитывать на usleep, который принимает микросекунды:

#include <unistd.h>

unsigned int microseconds;
...
usleep(microseconds);
  • 3
    Было бы не больно, если бы ответ был в форме MWE =)
  • 2
    Это занятый сон? Мне нужно уступить другому потоку во время сна; я могу использовать usleep для этого?
Показать ещё 4 комментария
710

В С++ 11 вы можете сделать это со стандартными библиотечными возможностями:

#include <chrono>
#include <thread>
std::this_thread::sleep_for(std::chrono::milliseconds(x));

Ясный и читаемый, больше не нужно угадывать, какие единицы выполняет функция sleep().

  • 6
    Определяет ли std :: this_thread :: sleep_for точку прерывания? Как boost :: this_thread_sleep делает?
  • 58
    Это правильный способ сделать это. Период. Нить кроссплатформенная, а также хронограф.
Показать ещё 17 комментариев
72

Чтобы оставаться портативным, вы можете использовать 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;
}

Этот ответ является дубликатом и ранее был опубликован в этом вопросе. Возможно, вы могли бы найти там некоторые полезные ответы.

  • 6
    Имейте в виду, что в многопоточной среде boost::this_thread::sleep добавляет точку прерывания в ваш код. boost.org/doc/libs/1_49_0/doc/html/thread/...
27

В зависимости от вашей платформы у вас может быть usleep или nanosleep. usleep устарел и был удален из последнего стандарта POSIX; nanosleep является предпочтительным.

  • 4
    Обратите внимание, что хотя usleep() объявлен в <unistd.h> , сбивает с толку, nanosleep() объявлен в <time.h> / <ctime> .
25

В Unix вы можете использовать usleep.

В Windows есть Сон.

  • 4
    и вызов Windows в миллисекундах.
  • 12
    Вы должны включить <unistd.h> или <Windows.h> соответственно.
Показать ещё 1 комментарий
15

nanosleep - лучший выбор, чем usleep - он более устойчив к прерываниям.

  • 5
    Я был знаком с usleep , но не с nanosleep . Вы должны предоставить пример использования его в Linux.
13

Почему бы не использовать библиотеку time.h? Работает в системах Windows и POSIX:

#include <iostream>
#include <time.h>

using namespace std;

void sleepcp(int milliseconds);

void sleepcp(int milliseconds) // Cross-platform sleep function
{
    clock_t time_end;
    time_end = clock() + milliseconds * CLOCKS_PER_SEC/1000;
    while (clock() < time_end)
    {
    }
}
int main()
{
    cout << "Hi! At the count to 3, I'll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

Исправленный код - теперь CPU остается в состоянии IDLE [2014.05.24]:

#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;
}
  • 17
    Одна из проблем с этим кодом состоит в том, что это занятый цикл, он будет продолжать использовать 100% одного ядра процессора. Функция sleep реализована вокруг вызова ОС, который переводит текущий поток в спящий режим и делает что-то еще, и только активирует поток, когда истечет указанное время.
  • 0
    Вы правы - он будет потреблять 100% одного ядра процессора. Итак, вот переписанный код с использованием системных функций сна - и он все еще кроссплатформенный:
Показать ещё 1 комментарий
7
#include <WinBase.h>

Синтаксис:

Sleep (  __in DWORD dwMilliseconds   );

Использование:

Sleep (1000); //Sleeps for 1000 ms or 1 sec
  • 2
    Что для этого нужно включить?
  • 0
    #include <WinBase.h>
Показать ещё 2 комментария
6

Если вы используете MS Visual С++ 10.0, вы можете сделать это со стандартными библиотечными возможностями:

Concurrency::wait(milliseconds);

вам понадобится:

#include <concrt.h>
  • 6
    Не используйте слово «стандарт», если вы на самом деле не имеете это в виду. <concrt.h> не является заголовком стандартной библиотеки - это может быть библиотека платформы; в этом случае вы должны четко указать предпосылки.
3

На платформах с функцией 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.
    }
}

Однако в настоящее время существуют лучшие альтернативы.

  • 0
    Невозможно выполнить компиляцию в VS2017 на компьютере с Windows: error LNK2019: unresolved external symbol _select@20 referenced in function "void __cdecl sleep(unsigned long)" (?sleep@@YAXK@Z)
  • 0
    @kayleeFrye_onDeck Это компилируется. Просто не связывает. Поиск ваших документов Windows.
3

Способом спать вашей программой в С++ является метод 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
  • 3
    Что вы имеете в виду, что нет предела? Это, безусловно, имеет предел, который составляет 0xFFFFFFFE. Ожидание 0xFFFFFFFF просто не истечет (это означает, что он будет ждать окончания программы).
  • 0
    Я не это имел ввиду, Иззи, извини за наше недоразумение. Я имел в виду, что вы можете ввести любое положительное количество миллисекунд. Так что будет ждать столько миллисекунд, чтобы закрыть программу. Если вы не понимаете, скажите, пожалуйста, я объясню вам больше.
Показать ещё 1 комментарий
3

Выбор вызова - это способ получения большей точности (время сна может быть указано в наносекундах).

  • 0
    Хотя это может быть ценным советом для решения проблемы, хороший ответ также демонстрирует решение. Пожалуйста, измените, чтобы предоставить пример кода, чтобы показать, что вы имеете в виду. В качестве альтернативы, попробуйте написать это как комментарий.
1

Использовать асинхронные потоки ввода/вывода Boost, спящий режим за миллисекунды;

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

boost::thread::sleep(boost::get_system_time() + boost::posix_time::millisec(1000));
  • 0
    причина для отрицательного голосования?
  • 0
    Что на самом деле произойдет, если вы попытаетесь уснуть в течение 3 миллисекунд? Это будет 15-16 миллисекунд вместо этого? Вы измерили это?
0

Как замена Win32 для систем POSIX:

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

while (1) {
    printf(".");
    Sleep((unsigned int)(1000.0f/20.0f)); // 20 fps
}
  • 0
    Предпочитайте nanosleep() usleep() : последний не рекомендуется и был удален из самого последнего стандарта POSIX.

Ещё вопросы

Сообщество Overcoder
Наверх
Меню