Sleep for milliseconds

Question

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++?

Gamine

You should be aware that, in Windows anyway, Sleep() has millisecond precision, but it's accuracy can be orders of magnitude higher. You may think your sleeping for 4 milliseconds, but actually sleep for 400. – Economist

@John Dibling: I think he's using POSIX sleep, not win32 Sleep given "x seconds". – Selia

Although C and C++ have different name mangling, which can be a source of bugs and incompatibilities, in most cases it's fine to use C headers in C++. However, if you want to be absolutely sure that nothing goes wrong, #include the C header inside an extern "C" {} block. Also, if you have C and C++ source files in the same project, it's highly recommended that you do this in order to avoid any problems, especially if you include the same headers in both kinds of source files (in which case this is necessary). If you have a purely C++ project, it might just work with no problem at all. – Adolphus

@JohnDibling no, not 400ms. The worst precision you might ever have gotten was from Windows 9x, whose GetTickCount had 55ms resolution; later versions had 16ms resolution or less. One user thought he was getting 16ms resolution from Sleep but then reported that Sleep itself was fairly accurate, and the apparent imprecision was caused by using GetTickCount to measure the passage of time. – Glorygloryofthesnow

I had just fallen into this MS trap in Windows 10. Using the QueryPerformanceCounter a Sleep(1) returns after about 14 ms. – Autochthonous

There's usleep() on POSIX compliant platforms.. – Bataan

@Qwertie: On a busy system, with other processes waiting to run, your process might not get scheduled again for a fair while after its wakeup time. Of course this could have happened after it got pre-empted if it didn't sleep before using up its timeslice, but it's worth mentioning as a warning: once people start writing code with short sleeps, it's easy to forget that it's just a minimum sleep time, not something you can rely on in all conditions. e.g. you might assume that 10x 100ms sleeps will add up to about a second, but you should check clock_gettime against an older timestamp. – Encephalomyelitis

And as Is usleep() in C implemented as busy wait? points out, for some APIs like usleep, the time isn't even a lower bound: a signal can wake the thread earlier. – Encephalomyelitis

Answer 1

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

Armilla

Is it a busy sleep? I need to yield to another thread during sleep; can I use usleep for that? – Jori

It's not a busy wait https://mcmap.net/q/54885/-is-usleep-in-c-implemented-as-busy-wait, and nanosleepmay be a better choice since usleep is obsolete. – Shut

Niet, please consider mentioning @HighCommander4's answer which is more portable if you have a C++11 compiler. – Gook

usleep() deprecated in POSIX in 2001 and removed in 2008. – Increasing

Apparently usleep() is deprecated, so I wrote an example here to show how to write your own sleep_us() (or usleep()) function as a wrapper around nanosleep(). – Mikey

Answer 2

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.

Lentamente

Does std::this_thread::sleep_for define an interruption point? Like boost::this_thread_sleep does? – Odelsting

This is the right way to do it. Period. Thread is cross platform as well as chrono. – Lagting

@Void. A very good way certainly, but "the" and "period" are awfully strong words. – Vehicular

this method is not the best because it has delay, as mentioned in Note that multi-threading management may cause certain delay beyond this – Morley

@Valen: Is there another method that avoids such delays? – Lentamente

@Lentamente , probably not, or need to travel inside the os, or use a single core, single thread processor lol. – Morley

Is it a busy sleep? I need to yield to another thread during sleep; can I use sleep_for for that? – Jori

@Michael: It's not a busy sleep, it will yield to other threads. – Lentamente

@Lagting If possible, certainly! But if you can't use C++11, or if you're compiling without standard library support, you must do something else. – Ague

I support @Morley in that way, that a much better name for the method would be std::this_thread::REQUEST_reactivation_after(...). But this is called sleep as long everyone can think of ... – Odelsting

@Jori what is meant by busy_sleep? – Bucella

Is this interruptable with a signal? – Biaxial

@Abhinav Gauniyal It means checking very frequently if it should start again, therefore using a lot of CPU doing nothing. As you probably guessed, this is usually undesirable, especially when you have other threads that have actual work to do. – Fulllength

Is there any rule or reason why one of us can't just edit the accepted answer to say what this answer says? This is the correct answer after all. – Nakia

@MartinMeeser, no the standard did not choose to support the interruption point feature of Boost threads at all. – Nakia

Does it bother anyone else to have a statement with this_thread, just for a sleep function. It really throws me off to include <thread> when there is no threading in my program – Tablespoon

Are you sure the actual minimum time isn't 15-16 ms in some cases (even if e.g. 3 ms is specified)? Have you measured it (e.g. with the high-resolution timer)? – Sherlock

From C++11 you can use even shorter form using numeric literals std::this_thread::sleep_for(123ms);. See my other post here. – Medallion

regarding "the right way": Original question asked for C++. Since C++11, this is the definitive answer. Alternatives (like nanosleep, or usleep) are POSIX, and thus they are C solutions and portable to the degree that POSIX is. Both solutions have in common that they rely on the OS scheduler, and thus typically add granularity and a "at least" condition. For high precision, use a busy wait on a high resolution timer. – Hydrogenolysis

How can you cancel this sleep - without implementing a busy-wait – Engaged

@TobiAkinyemi Presumably there is another thread involved to trigger the cancellation. In such cases, you would typically use a condition variable as described e.g. in this answer. If that does not answer your question, probably best to ask it in a new question rather than a comment. – Lentamente

@Lentamente Thanks. I was concerned with condition_variable busy waiting (which I found was true when doing some research some months ago). However, It's much easier to use the std apis than having to implement my own OS-specific impls, so until I reach the performance issues I was concerned about, I'll go with that solution – Engaged

Answer 3

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.

Querida

Keep in mind that - in a multi-threaded environment -boost::this_thread::sleep adds an interruption point to your code. boost.org/doc/libs/1_49_0/doc/html/thread/… – Odelsting

Answer 4

In Unix you can use usleep.

In Windows there is Sleep.

Merilynmeringue

and the Windows call is in milliseconds. – Erle

You have to include <unistd.h> or <Windows.h> respectively. – Greyhen

Yes, but couldn't the actual time resolution be 15-16 ms (even if the unit in the call is 1 ms) and thus the minimum time be 15-16 ms? – Sherlock

Answer 5

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

#include <chrono>
#include <thread>

using namespace std::chrono_literals;

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

Medallion

How is this implemented? 123ms looks weird. – Inspiratory

In short, it is implemented as user-defined literal, similarly as you define other operators: long double operator "" ms(long double) In my opinion is is better readable than chrono::milliseconds(1000). See [User-defined literals][1] for more info. [1]: en.cppreference.com/w/cpp/language/user_literal – Medallion

Answer 6

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.

Selia

Note that while usleep() is declared in <unistd.h>, confusingly, nanosleep() is declared in <time.h>/<ctime>. – Greyhen

Answer 7

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

CPU stays in IDLE state:

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

Middleclass

@BartGrzybicki i know this is an old answer and all, but in Visual Studio 2017 on a windows machine, #ifdef WIN32 doesn't evaluate as true by-default. – Censorship

@Censorship Code is wrong. It should be #ifdef _WIN32. – Boccie

@Boccie I knew that! But not when I wrote that... lol. Thanks for the follow-up! – Censorship

Answer 8

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

Scaremonger

I was familiar with usleep, but not nanosleep. You should provide an example of using it on Linux. – Citrin

Answer 9

#include <windows.h>

Syntax:

Sleep (  __in DWORD dwMilliseconds   );

Usage:

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

Condone

What do you need to include for this? – Alexandretta

#include <WinBase.h> – Condone

No, you need to #include <windows.h> – Alexandretta

The question strongly implies that a POSIX solution is required. – Autry

Answer 10

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

Concurrency::wait(milliseconds);

you will need:

#include <concrt.h>

Achorn

Don't use the word "standard" when you don't actually mean it. <concrt.h> is not a Standard Library header - it may be a platform library; in which case you should state the prerequisites clearly. – Autry

Not only that, but we'd expect a linux question to be using one of the popular compilers. – Autry

Cannot be used with CLR (compiler option /clr). – Autochthonous

This was posted in 2015. Is there any reason you'd ever use this instead of std::chrono? Perhaps a codebase that wasn't ready to move to C++11 yet? I assume it's pretty much obsolete in 2023. – Encephalomyelitis

Answer 11

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.

Unworthy

Can't seem to compile in VS2017 on a Windows machine: error LNK2019: unresolved external symbol _select@20 referenced in function "void __cdecl sleep(unsigned long)" (?sleep@@YAXK@Z) – Censorship

@Censorship It does compile. Just doesn't link. Lookup you Windows docs. – Unworthy

what header do you use for timeval ?? – Lewellen

@TotteKarlsson <sys/time.h>. – Unworthy

Answer 12

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

Damalus

While this might be a valuable hint to solve the problem, a good answer also demonstrates the solution. Please edit to provide example code to show what you mean. Alternatively, consider writing this as a comment instead. – Autry

Answer 13

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

Merlynmermaid

What do you mean it has no limit? It surely has limit which is 0xFFFFFFFE. Waiting for 0xFFFFFFFF will just not time out (which means it will wait till program ends). – Madison

I didn't mean it like that Izzy, sorry for our misunderstanding. I meant that you can enter any positive number of milliseconds. So it will wait that many milliseconds to close the program. If you do not understand please say so, I shall explain to you more. – Merlynmermaid

Yes, but what it the actual time resolution? Couldn't it be 15-16 ms in some cases? E.g., if you use Sleep(3) will it actually sleep for 3 ms or will it instead be 15-16 ms? – Sherlock

I don't think "windows.h" is a standard POSIX or Linux header... – Autry

"The way to sleep your program in C++ is the Sleep(int) method" - That was a pretty odd thing to write in 2014, 3 years after C++11 was released. – Astraphobia

Answer 14

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

Measles

What will actually happen if you try to sleep for 3 milliseconds? Will it be 15-16 milliseconds instead? Have you measured it? – Sherlock

Answer 15

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

Decury

Answer 16

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
}

Letishaletitia

Prefer nanosleep() to usleep(): the latter is deprecated and has been deleted from the most recent POSIX standard. – Autry

Answer 17

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

Bingo

You probably meant usleep((X) * 1000) - which is one reason why functions are so much better than macros! – Autry

@TobySpeight yes, if it will be an expression where you sum up two number msleep(1 + 2), then the macro substitution will be usleep(1 + 2 * 1000) will be 2001 instead of 3000 Making usleep ((X) * 1000) , guarantees that (1+2) will be evaluated first. Just for those who are not aware, though it is basics of macros. Don't use them especially if you are not aware of how they work in principle. – Pulley

Answer 18

I use this:

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

example:

sleepms(200);

Samite

Answer 19

sleep for 10 seconds:

#include <thread>
#include <chrono>

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

for 10 milliseconds use 10ms

Eh