I know the POSIX sleep(x) function makes the program sleep for x seconds. Is there a function to make the program sleep for x milliseconds in C++?

5

20 Answers

In C++11, you can do this with standard library facilities:

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

Clear and readable, no more need to guess at what units the sleep() function takes.

24

Note that there is no standard C API for milliseconds, so (on Unix) you will have to settle for usleep, which accepts microseconds:

#include <unistd.h> unsigned int microseconds; ... usleep(microseconds);
5

To stay portable you could use Boost::Thread for sleeping:

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

This answer is a duplicate and has been posted in this question before. Perhaps you could find some usable answers there too.

1

In Unix you can use usleep.

In Windows there is Sleep.

3

Depending on your platform you may have usleep or nanosleep available. usleep is deprecated and has been deleted from the most recent POSIX standard; nanosleep is preferred.

1
#include <chrono> #include <thread> std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // sleep for 1 second

Remember to import the two headers.

1

Why don't use time.h library? Runs on Windows and POSIX systems(Don't use this code in production!):

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

Corrected code - now CPU stays in IDLE state [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; }
5

nanosleep is a better choice than usleep - it is more resilient against interrupts.

1
#include <windows.h>

Syntax: 

Sleep ( __in DWORD dwMilliseconds );

Usage: 

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

From C++14 using std and also its numeric literals:

#include <chrono> #include <thread> using namespace std::chrono; std::this_thread::sleep_for(123ms);
2

If using MS Visual C++ 10.0, you can do this with standard library facilities:

Concurrency::wait(milliseconds);

you will need:

#include <concrt.h>
3

On platforms with the select function (POSIX, Linux, and Windows) you could do:

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

However, there are better alternatives available nowadays.

4

The way to sleep your program in C++ is the Sleep(int) method. The header file for it is #include "windows.h."

For example:

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

The time it sleeps is measured in milliseconds and has no limit.

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

Select call is a way of having more precision (sleep time can be specified in nanoseconds).

1

Use Boost asynchronous input/output threads, sleep for x milliseconds;

#include <boost/thread.hpp> #include <boost/asio.hpp> boost::thread::sleep(boost::get_system_time() + boost::posix_time::millisec(1000));
1

The question is old, but I managed to figure out a simple way to have this in my app. You can create a C/C++ macro as shown below use it:

#ifndef MACROS_H #define MACROS_H #include <unistd.h> #define msleep(X) usleep(X * 1000) #endif // MACROS_H
1

Elegant solution from the one answer, bit modified.. One can easilly add select() usage if there's no better functionality available. Just make function that uses select() etc. ..

Code:

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

As a Win32 replacement for POSIX systems:

void Sleep(unsigned int milliseconds) { usleep(milliseconds * 1000); } while (1) { printf("."); Sleep((unsigned int)(1000.0f/20.0f)); // 20 fps }
1

I use this:

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

example:

sleepms(200);

for C use /// in gcc.

#include <windows.h>

then use Sleep(); /// Sleep() with capital S. not sleep() with s .

//Sleep(1000) is 1 sec /// maybe.

clang supports sleep(), sleep(1) is for 1 sec time delay/wait.

1