Wie fügen Sie einem C++ - Programm eine zeitgesteuerte Verzögerung hinzu?

Question

Ich versuche, eine zeitgesteuerte Verzögerung in einem C++ - Programm hinzuzufügen, und fragte mich, ob jemand irgendwelche Vorschläge hat, was ich versuchen kann oder Informationen, die ich mir anschauen kann?

Ich wünschte, ich hätte mehr Details darüber, wie ich diese zeitgesteuerte Verzögerung implementiere, aber bis ich mehr Informationen darüber habe, wie man eine zeitgesteuerte Verzögerung hinzufügt, bin ich mir nicht sicher, wie ich das überhaupt versuchen sollte.

Answer 1

Win32: Sleep(milliseconds) ist, was Sie, was

Unix: usleep(microseconds) ist das, was Sie wollen.

sleep() dauert nur einige Sekunden, was oft zu lang ist.

Answer 2

Haben Sie etwas so einfaches wie

sleep(3); 

Answer 3

Syntax wollen:

Leere Schlaf (unsigned Sekunden);

sleep() unterbricht die Ausführung für ein Intervall (Sekunden). Mit einem Aufruf des Ruhezustands wird das aktuelle Programm für die durch die Argumentsekunden angegebene Anzahl von Sekunden an der Ausführung gehindert. Das Intervall ist nur auf die nächste Hundertstelsekunde genau oder auf die Genauigkeit des Betriebssystemtakts, je nachdem, was weniger genau ist.

Answer 4

Sie können auch wählen (2) verwenden, wenn Sie mikrosekundengenau wollen (dies funktioniert auf der Plattform, die nicht usleep (3))

Der folgende Code Sekunde für 1,5 wartet:

#include <sys/select.h> 
#include <sys/time.h> 
#include <unistd.h>` 

int main() { 
    struct timeval t; 
    t.tv_sec = 1; 
    t.tv_usec = 500000; 
    select(0, NULL, NULL, NULL, &t); 
} 

`

Answer 5

#include <unistd.h> 
usleep(3000000); 

Dies wird auch drei Sekunden lang schlafen. Sie können die Zahlen jedoch etwas verfeinern.

Answer 6

Beachten Sie, dass dies nicht garantiert, dass die Zeit, die der Thread schläft, irgendwo in der Nähe des Schlafzeitraums liegt, es garantiert nur, dass die Zeit bis zur Ausführung des Threads mindestens der gewünschte Betrag ist. Die tatsächliche Verzögerung variiert in Abhängigkeit von den Umständen (insbesondere der Belastung der betreffenden Maschine) und kann um Größenordnungen höher sein als die gewünschte Schlafzeit.

Außerdem listen Sie nicht, warum Sie schlafen müssen, aber Sie sollten im Allgemeinen vermeiden, Verzögerungen als eine Methode der Synchronisierung zu verwenden.

Answer 7

Ja, Schlaf ist wahrscheinlich die Funktion der Wahl hier. Beachten Sie, dass die in die Funktion verbrachte Zeit die kürzeste Zeit ist, die der aufrufende Thread inaktiv ist. Wenn Sie beispielsweise mit 5 Sekunden in den Schlafmodus wechseln, ist Ihr Thread garantiert mindestens 5 Sekunden lang inaktiv. Könnte 6, 8 oder 50 sein, je nachdem, was das Betriebssystem macht. (Während der optimalen Betriebssystemausführung ist dies sehr nahe bei 5).
Eine weitere nützliche Funktion der Schlaffunktion ist das Übergeben von 0. Dies erzwingt einen Kontextwechsel von Ihrem Thread.

Einige zusätzliche Informationen:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

Answer 8

Viele andere haben zum Schlafen gute Informationen zur Verfügung gestellt. Ich stimme mit Wedge überein, dass ein Schlaf selten die geeignetste Lösung ist.

Wenn du schläfst, während du auf etwas wartest, dann bist du besser dran, auf dieses Ding/Ereignis zu warten. Schauen Sie sich Konditionsvariablen dafür an.

Ich weiß nicht, welches Betriebssystem Sie versuchen, dies zu tun, aber für Threading und Synchronisation können Sie die Boost Threading-Bibliotheken (Boost Condition Varriable) suchen.

Jetzt zum anderen Extrem wechseln, wenn Sie versuchen, auf außergewöhnlich kurze Zeiträume zu warten, dann gibt es ein paar Hackstil-Optionen. Wenn Sie an einer Art eingebetteter Plattform arbeiten, auf der kein 'sleep' implementiert ist, können Sie eine einfache Schleife (für/while usw.) mit einem leeren Körper versuchen (achten Sie darauf, dass der Compiler sie nicht optimiert). Natürlich hängt die Wartezeit in diesem Fall von der spezifischen Hardware ab. Für wirklich kurze "Wartezeiten" können Sie eine Assembly "nop" versuchen. Ich bezweifle sehr, dass dies das ist, wonach Sie suchen, aber ohne zu wissen, warum Sie warten müssen, ist es schwierig, genauer zu sein.

Answer 9

Unter Windows können Sie die Windows-Bibliothek einschließen und "Sleep (0)" verwenden um das Programm zu schlafen. Es dauert ein Wert, der Millisekunden darstellt.

Answer 10

Eine aktualisierte Antwort für C++ 11:

Verwenden Sie die sleep_for und sleep_until Funktionen:

#include <chrono> 
#include <thread> 

int main() { 
    using namespace std::this_thread; // sleep_for, sleep_until 
    using namespace std::chrono; // nanoseconds, system_clock, seconds 

    sleep_for(nanoseconds(10)); 
    sleep_until(system_clock::now() + seconds(1)); 
} 

Mit diesen Funktionen gibt es keine Notwendigkeit mehr, ständig neue Funktionen für eine bessere Auflösung hinzuzufügen: sleep, usleep, nanosleep usw. sleep_for und sleep_until sind Vorlagenfunktionen, die Werte von jeder Auflösung über chrono Typen annehmen können; Stunden, Sekunden, Femtosekunden usw.

In C++ 14 Sie können weiterhin den Code mit den wörtlichen Suffixe vereinfachen für nanoseconds und seconds:

#include <chrono> 
#include <thread> 

int main() { 
    using namespace std::this_thread;  // sleep_for, sleep_until 
    using namespace std::chrono_literals; // ns, us, ms, s, h, etc. 
    using std::chrono::system_clock; 

    sleep_for(10ns); 
    sleep_until(system_clock::now() + 1s); 
} 

Beachten Sie, dass die tatsächliche Dauer eines Schlaf auf das hängt Implementierung: Sie können um 10 Nanosekunden bitten zu schlafen, aber eine Implementierung könnte am Ende für eine Millisekunde schlafen, wenn das die kürzeste ist.

Answer 11

fand ich, dass "_sleep(milliseconds);" (ohne die Anführungszeichen) gut für Win32 funktioniert, wenn Sie die chrono Bibliothek

Z. B sind:

#include <chrono> 

using namespace std; 

main 
{ 
    cout << "text" << endl; 
    _sleep(10000); // pauses for 10 seconds 
} 

Achten Sie darauf, den Unterstrich vor dem Schlafen sind.

Answer 12

Sie können diesen Code-Schnipsel versuchen:

#include<chrono> 
#include<thread> 

int main(){ 
    std::this_thread::sleep_for(std::chrono::nanoseconds(10)); 
    std::this_thread::sleep_until(std::chrono::system_clock::now() + std::chrono::seconds(1)); 
} 

Answer 13

für feste Zeitausgabe in cpp zu verzögern, können Sie die Sleep() Funktion von windows.h Header-Datei Syntax für Sleep einschließlich() Funktion ist Sleep (time_in_ms) als

cout<<"Apple\n"; 
Sleep(3000); 
cout<<"Mango"; 

OUTPUT. Der obige Code wird Apple drucken und 3 Sekunden warten, bevor Mango gedruckt wird.