Is there an alternative sleep function in C to milliseconds?
CLinuxSleepC Problem Overview
I have some source code that was compiled on Windows. I am converting it to run on Red Hat Linux.
The source code has included the <windows.h>
header file and the programmer has used the Sleep()
function to wait for a period of milliseconds. This won't work on the Linux.
However, I can use the sleep(seconds)
function, but that uses integer in seconds. I don't want to convert milliseconds to seconds. Is there a alternative sleep function that I can use with gcc compiling on Linux?
C Solutions
Solution 1 - C
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
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;
}
Solution 2 - C
You can use this cross-platform function:
#ifdef WIN32
#include <windows.h>
#elif _POSIX_C_SOURCE >= 199309L
#include <time.h> // for nanosleep
#else
#include <unistd.h> // for usleep
#endif
void sleep_ms(int milliseconds){ // cross-platform sleep function
#ifdef WIN32
Sleep(milliseconds);
#elif _POSIX_C_SOURCE >= 199309L
struct timespec ts;
ts.tv_sec = milliseconds / 1000;
ts.tv_nsec = (milliseconds % 1000) * 1000000;
nanosleep(&ts, NULL);
#else
if (milliseconds >= 1000)
sleep(milliseconds / 1000);
usleep((milliseconds % 1000) * 1000);
#endif
}
Solution 3 - C
Alternatively to usleep()
, which is not defined in POSIX 2008 (though it was defined up to POSIX 2004, and it is evidently available on Linux and other platforms with a history of POSIX compliance), the POSIX 2008 standard defines nanosleep()
:
> nanosleep
- high resolution sleep
>
> #include
Solution 4 - C
Beyond usleep, the humble select with NULL file descriptor sets will let you pause with microsecond precision, and without the risk of SIGALRM
complications.
sigtimedwait and sigwaitinfo offer similar behavior.
Solution 5 - C
#include <unistd.h>
int usleep(useconds_t useconds); //pass in microseconds