How can I block my thread (maybe process) for nanoseconds or maybe for a milliseconds (at least) period?
Please note that I can't use sleep, because the argument to sleep is always in seconds.
C – How to Make a Thread Sleep for Nanoseconds or Milliseconds
c++linuxpthreadssleep
Related Solutions
Yes - older POSIX standards defined usleep(), so this is available on Linux:
int usleep(useconds_t usec);DESCRIPTION
The usleep() function suspends execution of the calling thread for (at least) usec microseconds. The sleep may be lengthened slightly by any system activity or by the time spent processing the call or by the granularity of system timers.
usleep() takes microseconds, so you will have to multiply the input by 1000 in order to sleep in milliseconds.
usleep() has since been deprecated and subsequently removed from POSIX; for new code, nanosleep() is preferred:
#include <time.h> int nanosleep(const struct timespec *req, struct timespec *rem);DESCRIPTION
nanosleep()suspends the execution of the calling thread until either at least the time specified in*reqhas elapsed, or the delivery of a signal that triggers the invocation of a handler in the calling thread or that terminates the process.The structure timespec is used to specify intervals of time with nanosecond precision. It is defined as follows:
struct timespec { time_t tv_sec; /* seconds */ long tv_nsec; /* nanoseconds */ };
An example msleep() function implemented using nanosleep(), continuing the sleep if it is interrupted by a signal:
#include <time.h>
#include <errno.h>
/* msleep(): Sleep for the requested number of milliseconds. */
int msleep(long msec)
{
struct timespec ts;
int res;
if (msec < 0)
{
errno = EINVAL;
return -1;
}
ts.tv_sec = msec / 1000;
ts.tv_nsec = (msec % 1000) * 1000000;
do {
res = nanosleep(&ts, &ts);
} while (res && errno == EINTR);
return res;
}
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.
Best Answer
nanosleeporclock_nanosleepis the function you should be using (the latter allows you to specify absolute time rather than relative time, and use the monotonic clock or other clocks rather than just the realtime clock, which might run backwards if an operator resets it).Be aware however that you'll rarely get better than several microseconds in terms of the resolution, and it always rounds up the duration of sleep, rather than rounding down. (Rounding down would generally be impossible anyway since, on most machines, entering and exiting kernelspace takes more than a microsecond.)
Also, if possible I would suggest using a call that blocks waiting for an event rather than sleeping for tiny intervals then polling. For instance,
pthread_cond_wait,pthread_cond_timedwait,sem_wait,sem_timedwait,select,read, etc. depending on what task your thread is performing and how it synchronizes with other threads and/or communicates with the outside world.