Is there an alternative sleep function in C to milliseconds?

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 byany system activity or by the time spent processing the call or by thegranularity 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 *req has elapsed, or thedelivery of a signal that triggers the invocation of a handler in thecalling 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;}

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

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 <time.h>int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);

The nanosleep() function shall cause the current thread to be suspended from execution until either the time interval specified by the rqtp argument has elapsed or a signal is delivered to the calling thread, and its action is to invoke a signal-catching function or to terminate the process. The suspension time may be longer than requested because the argument value is rounded up to an integer multiple of the sleep resolution or because of the scheduling of other activity by the system. But, except for the case of being interrupted by a signal, the suspension time shall not be less than the time specified by rqtp, as measured by the system clock CLOCK_REALTIME.

The use of the nanosleep() function has no effect on the action or blockage of any signal.