Gibt es eine alternative Schlaffunktion in C zu Millisekunden?

nanosleep - Hochauflösender Schlaf

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

Die nanosleep() Funktion bewirkt, dass die Ausführung des aktuellen Threads bis zu dem durch rqtp angegebenen Zeitintervall ausgesetzt wird Argument abgelaufen ist oder ein Signal an den aufrufenden Thread geliefert wird und seine Aktion darin besteht, eine signalabfangende Funktion aufzurufen oder den Prozess zu beenden. Die Aussetzungszeit kann länger als angefordert sein, weil der Argumentwert auf ein ganzzahliges Vielfaches der Schlafauflösung aufgerundet wird oder weil das System andere Aktivitäten plant. Außer im Fall einer Unterbrechung durch ein Signal darf die Aussetzungszeit jedoch nicht kürzer sein als die in rqtp festgelegte Zeit , gemessen von der Systemuhr CLOCK_REALTIME.

Die Verwendung des nanosleep() Funktion hat keinen Einfluss auf die Aktion oder Blockierung von Signalen.

Ja - ältere POSIX-Standards haben usleep() definiert , also ist dies unter Linux verfügbar:

int usleep(useconds_t usec);

BESCHREIBUNG

Die Funktion usleep() unterbricht die Ausführung des aufrufenden Threads für (mindestens) usec Mikrosekunden. Der Ruhezustand kann durch Systemaktivitäten oder durch die Zeit, die für die Verarbeitung des Anrufs aufgewendet wird, oder durch die Granularität der System-Timer etwas verlängert werden.

usleep() dauert Mikrosekunden , also müssen Sie die Eingabe mit 1000 multiplizieren, um in Millisekunden schlafen zu können.

usleep() ist seitdem veraltet und wurde anschließend aus POSIX entfernt; für neuen Code nanosleep() wird bevorzugt:

#include <time.h>

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

BESCHREIBUNG

nanosleep() setzt die Ausführung des aufrufenden Threads bis mindestens zu der in *req angegebenen Zeit aus abgelaufen ist, oder die Lieferung eines Signals, das den Aufruf eines Handlers im aufrufenden Thread auslöst oder den Prozess beendet.

Die Struktur timepec wird verwendet, um Zeitintervalle mit Nanosekunden-Präzision anzugeben. Sie ist wie folgt definiert:

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

Ein Beispiel msleep() Funktion implementiert mit nanosleep() , setzt den Schlaf fort, wenn er durch ein Signal unterbrochen wird:

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

Sie können diese plattformübergreifende Funktion verwenden:

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