Esiste una funzione di sonno alternativa in C a millisecondi?

Ho del codice sorgente compilato su Windows. Lo sto convertendo per funzionare su Red Hat Linux.

Il codice sorgente ha incluso il <windows.h>file header e il programmatore ha usato la Sleep()funzione per attendere un periodo di millisecondi. Questo non funzionerà su Linux.

Tuttavia, posso usare la sleep(seconds)funzione, ma utilizza numeri interi in pochi secondi. Non voglio convertire millisecondi in secondi. Esiste una funzione sleep alternativa che posso usare con la compilazione gcc su Linux?

Sì - definiti standard POSIX precedenti usleep(), quindi disponibile su Linux:

   int usleep(useconds_t usec);

DESCRIZIONE

La funzione usleep () sospende l'esecuzione del thread chiamante per (almeno) microsecondi usec. Il sonno può essere leggermente allungato da qualsiasi attività di sistema o dal tempo impiegato per l'elaborazione della 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 fino a quando non *reqè trascorso almeno il tempo specificato in oppure il recapito di un segnale che attiva l'invocazione di un gestore nel thread chiamante o termina il processo.

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

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

Una msleep()funzione di esempio implementata usando nanosleep(), continuando il sonno se viene 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;
}

È possibile 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
    usleep(milliseconds * 1000);
#endif
}

In alternativa 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 - sonno ad alta risoluzione

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

La nanosleep()funzione deve sospendere l'esecuzione del thread corrente fino a quando non rqtpè trascorso l'intervallo di tempo specificato dall'argomento o viene inviato un segnale al thread chiamante e la sua azione è invocare una funzione di cattura del segnale o terminare il processo. Il tempo di sospensione potrebbe essere più lungo di quanto richiesto perché il valore dell'argomento viene arrotondato per eccesso a un multiplo intero della risoluzione del sonno o a causa della pianificazione di altre attività da parte del sistema. Tuttavia, tranne nel caso di interruzione di un segnale, il tempo di sospensione non deve essere inferiore al tempo specificato da rqtp, misurato dall'orologio di sistema CLOCK_REALTIME.

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

Oltre a dormire , l'umile selezione con set di descrittori di file NULL ti consentirà di mettere in pausa con precisione al microsecondo e senza il rischio di SIGALRMcomplicazioni.

sigtimedwait e sigwaitinfo offrono comportamenti simili.

#include <unistd.h>

int usleep(useconds_t useconds); //pass in microseconds

#include <stdio.h>
#include <stdlib.h>
int main () {

puts("Program Will Sleep For 2 Seconds");

system("sleep 2");      // works for linux systems


return 0;
}