Alternativement à usleep()
, qui n'est pas défini dans POSIX 2008 (bien qu'il ait été défini jusqu'à POSIX 2004, et qu'il soit évidemment disponible sur Linux et d'autres plates-formes avec un historique de conformité POSIX), la norme POSIX 2008 définit nanosleep()
:
nanosleep
- sommeil haute résolution#include <time.h> int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
Le
nanosleep()
La fonction doit entraîner la suspension de l'exécution du thread en cours jusqu'à l'intervalle de temps spécifié par lerqtp
L'argument s'est écoulé ou un signal est 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é parce que la valeur de l'argument est arrondie à un multiple entier de la résolution de veille ou à cause de la planification d'autres activités 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é parrqtp
, tel que mesuré par l'horloge système CLOCK_REALTIME.L'utilisation du
nanosleep()
fonction n'a aucun effet sur l'action ou le blocage de tout signal.
Oui - les anciennes normes POSIX définies usleep()
, c'est donc disponible sous Linux :
int usleep(useconds_t usec);
DESCRIPTIF
La fonction usleep() suspend l'exécution du thread appelant pendant (au moins) usec 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 temporisateurs du système.
usleep()
prend microsecondes , vous devrez donc multiplier l'entrée par 1000 pour dormir en millisecondes.
usleep()
a depuis été obsolète puis supprimé de POSIX ; pour le nouveau code, nanosleep()
est préféré :
#include <time.h> int nanosleep(const struct timespec *req, struct timespec *rem);
DESCRIPTIF
nanosleep()
suspend l'exécution du thread appelant jusqu'à au moins le temps spécifié dans*req
s'est écoulé, ou la livraison d'un signal qui déclenche l'invocation 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 de l'ordre de la nanoseconde. Il est défini comme suit :
struct timespec { time_t tv_sec; /* seconds */ long tv_nsec; /* nanoseconds */ };
Un exemple msleep()
fonction implémentée en utilisant nanosleep()
, poursuivant 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
if (milliseconds >= 1000)
sleep(milliseconds / 1000);
usleep((milliseconds % 1000) * 1000);
#endif
}