sonno per millisecondi

Question

so che la funzione POSIX sleep(x) obbliga il programma per x secondi. Esiste una funzione per far dormire il programma per x millisecondi in C++?

Answer 1

Si noti che non v'è alcuna API standard C per millisecondi, così (su Unix) si dovrà accontentare di usleep, che accetta microsecondi:

#include <unistd.h> 

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

Answer 2

di rimanere portatile è possibile utilizzare Boost::Thread per dormire:

#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; 
} 

Questa risposta è una copia duplicata ed è stata pubblicata in this question prima. Forse potresti trovare anche alcune risposte utilizzabili.

Answer 3

nanosleep è una scelta migliore rispetto usleep - è più resistente contro interrupt.

Answer 4

A seconda della piattaforma si può avere usleep o nanosleep disponibili. usleep è obsoleto ed è stato eliminato dallo standard POSIX più recente; nanosleep è preferito.

Answer 5

In Unix è possibile utilizzare usleep.

In Windows c'è Sleep.

Answer 6

Select chiamata è un modo di avere una maggiore precisione (tempo di sonno può essere specificato in nanosecondi).

Answer 7

In C++ 11, si può fare questo con funzionalità della libreria standard:

#include <chrono> 
#include <thread> 

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

chiaro e leggibile, non più bisogno di indovinare a quale unità la funzione sleep() prende.

Answer 8

#include <WinBase.h> 

Sintassi:

Sleep ( __in DWORD dwMilliseconds ); 

Usage:

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

Answer 9

Perché non utilizzare time.h biblioteca? Gira su sistemi Windows e POSIX:

codice

#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; 
} 

Corretto - ora CPU rimane in stato di 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; 
} 

Answer 10

Il modo di dormire il vostro programma in C++ è il metodo Sleep(int). Il file di intestazione perché è #include "windows.h."

Ad esempio:

#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; 
} 

il tempo che dorme è misurato in millisecondi, senza limite.

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

Answer 11

Se si utilizza MS Visual C++ 10.0, è possibile farlo con funzionalità della libreria standard:

Concurrency::wait(milliseconds); 

è necessario:

#include <concrt.h> 

Answer 12

Sulle piattaforme con la funzione select (POSIX, Linux e Windows) che potreste fare:

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. 
    } 
} 

Tuttavia, ci sono alternative migliori disponibili al giorno d'oggi.

Answer 13

Utilizzare Boost di thread di input/output asincroni, sleep per x millisecondi;

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

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

Answer 14

In sostituzione Win32 per sistemi POSIX:

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

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