Esiste una funzione di sospensione alternativa in C in millisecondi?

In alternativa a usleep() , che non è definito in POSIX 2008 (sebbene sia stato definito fino a POSIX 2004, ed è evidentemente disponibile su Linux e altre piattaforme con una storia di conformità POSIX), lo standard POSIX 2008 definisce nanosleep() :

nanosleep - sospensione ad alta risoluzione

#include <time.h>
int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);

Il nanosleep() La funzione causerà la sospensione dall'esecuzione del thread corrente fino all'intervallo di tempo specificato da rqtp argomento è trascorso o un segnale viene inviato al thread chiamante e la sua azione è richiamare una funzione di cattura del segnale o terminare il processo. Il tempo di sospensione può essere più lungo di quanto richiesto perché il valore dell'argomento è arrotondato a un multiplo intero della risoluzione della sospensione oa causa della pianificazione di altre attività da parte del sistema. Ma, salvo il caso di essere interrotto da un segnale, il tempo di sospensione non deve essere inferiore al tempo specificato da rqtp , come misurato dall'orologio di sistema CLOCK_REALTIME.

L'uso del nanosleep() funzione non ha alcun effetto sull'azione o sul blocco di alcun segnale.

Sì, i vecchi standard POSIX definiti usleep() , quindi questo è disponibile su Linux:

int usleep(useconds_t usec);

DESCRIZIONE

La funzione usleep() sospende l'esecuzione del thread chiamante per (almeno) usec microsecondi. La sospensione può essere leggermente allungata da qualsiasi attività di sistema o dal tempo impiegato per elaborare la chiamata o dalla granularità dei timer di sistema.

usleep() richiede microsecondi , quindi dovrai moltiplicare l'input per 1000 per dormire in millisecondi.

usleep() da allora è stato deprecato e successivamente rimosso da POSIX; per il nuovo codice, nanosleep() è preferito:

#include <time.h>

int nanosleep(const struct timespec *req, struct timespec *rem);

DESCRIZIONE

nanosleep() sospende l'esecuzione del thread chiamante almeno fino al tempo specificato in *req è trascorso, o la consegna di un segnale che attiva l'invocazione di un gestore nel thread chiamante o che termina il processo.

La struttura timespec viene utilizzata per specificare intervalli di tempo con una precisione di nanosecondi. È definito come segue:

struct timespec {
    time_t tv_sec;        /* seconds */
    long   tv_nsec;       /* nanoseconds */
};

Un esempio msleep() funzione implementata usando nanosleep() , continuando il sonno se interrotto da un segnale:

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

Puoi utilizzare questa funzione multipiattaforma:

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