Existe-t-il une fonction de veille alternative en C à millisecondes?

J'ai du code source qui a été compilé sur Windows. Je le convertis pour qu'il fonctionne sur Red Hat Linux.

Le code source a inclus le <windows.h>fichier d'en-tête et le programmeur a utilisé la Sleep()fonction pour attendre une période de millisecondes. Cela ne fonctionnera pas sous Linux.

Cependant, je peux utiliser la sleep(seconds)fonction, mais cela utilise un entier en secondes. Je ne veux pas convertir des millisecondes en secondes. Existe-t-il une fonction de veille alternative que je peux utiliser avec la compilation gcc sous Linux?

Oui - les normes POSIX plus anciennes sont définies usleep(), elles sont donc disponibles sous Linux:

   int usleep(useconds_t usec);

LA DESCRIPTION

La fonction usleep () suspend l'exécution du thread appelant pendant (au moins) usleep () microsecondes. Le sommeil peut être légèrement allongé par toute activité du système ou par le temps passé à traiter l'appel ou par la granularité des minuteries système.

usleep()prend des microsecondes , vous devrez donc multiplier l'entrée par 1000 pour dormir en millisecondes.

usleep()a depuis été obsolète et par la suite supprimé de POSIX; pour le nouveau code, il nanosleep()est préférable:

   #include <time.h>

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

LA DESCRIPTION

nanosleep() suspend l'exécution du thread appelant au moins jusqu'à l'heure spécifiée dans *req soit écoulé, ou la livraison d'un signal qui déclenche l'appel d'un gestionnaire dans le thread appelant ou qui termine le processus.

La structure timespec est utilisée pour spécifier des intervalles de temps avec une précision nanoseconde. Il est défini comme suit:

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

Un exemple de msleep()fonction implémentée en utilisant nanosleep(), en continuant le sommeil s'il est interrompu par un 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;
}

Vous pouvez utiliser cette fonction multiplateforme:

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

Alternativement usleep(), qui n'est pas défini dans POSIX 2008 (bien qu'il ait été défini jusqu'à POSIX 2004, et il est évidemment disponible sur Linux et d'autres plates-formes avec un historique de conformité POSIX), le standard POSIX 2008 définit nanosleep():

nanosleep - sommeil haute résolution

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

La nanosleep()fonction entraînera la suspension du thread actuel de l'exécution jusqu'à ce que l'intervalle de temps spécifié par l' rqtpargument se soit écoulé ou qu'un signal soit délivré au thread appelant, et son action consiste à invoquer une fonction de capture de signal ou à terminer le processus. Le temps de suspension peut être plus long que demandé car la valeur de l'argument est arrondie à un multiple entier de la résolution du sommeil ou en raison de la planification d'une autre activité par le système. Mais, sauf en cas d'interruption par un signal, le temps de suspension ne doit pas être inférieur au temps spécifié par rqtp, tel que mesuré par l'horloge système CLOCK_REALTIME.

L'utilisation de la nanosleep()fonction n'a aucun effet sur l'action ou le blocage d'un signal.

Au-delà de l' usleep , l'humble select avec des ensembles de descripteurs de fichiers NULL vous permettra de faire une pause avec une précision de l'ordre de la microseconde, et sans risque de SIGALRMcomplications.

sigtimedwait et sigwaitinfo offrent un comportement similaire.

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