Hinzufügen einer zeitgesteuerten Verzögerung in C++

1. Verwendung des sleep() Systemaufrufs zum Hinzufügen einer zeitlichen Verzögerung in C++
2. Verwendung der Funktion usleep() zum Hinzufügen einer zeitlichen Verzögerung in C++
3. Verwendung der Funktion sleep_for() zum Hinzufügen einer zeitlichen Verzögerung in C++
4. Verwenden Sie die Funktion sleep_until(), um eine zeitgesteuerte Verzögerung in C++ hinzuzufügen

Dieses Tutorial gibt Ihnen eine kurze Anleitung zum Hinzufügen einer zeitgesteuerten Verzögerung in Ihrem C++-Programm.

Dies kann auf viele Arten erfolgen, indem einige Funktionen verwendet werden, die uns C++-Bibliotheken zur Verfügung stellen. Wir werden einige Funktionen zusammen mit ihrer funktionierenden Demo besprechen.

Jeder Prozess, Task oder Thread in einem Computerprogramm kann schlafen oder inaktiv werden. Dies bedeutet, dass die Ausführung des Prozesses für die Zeit, in der er sich im Ruhezustand befindet, angehalten werden kann.

Wenn das Ruheintervall abläuft oder ein Signal oder eine Unterbrechung die Wiederaufnahme der Ausführung bewirkt, wird die Ausführung wieder aufgenommen. Dazu gibt es verschiedene Methoden:

1. der Systemaufruf sleep()
2. die usleep()-Methode
3. die sleep_for()-Methode
4. die sleep_until()-Methode

Verwendung des sleep() Systemaufrufs zum Hinzufügen einer zeitlichen Verzögerung in C++

Ein sleep-Systemaufruf kann ein Programm (Task, Prozess oder Thread) in den Ruhezustand versetzen. Der Parameter time in einem typischen Systemaufruf sleep gibt an, wie viel Zeit das Programm braucht, um zu schlafen oder inaktiv zu bleiben.

Die Sprache C++ hat keine sleep-Funktion. Diese Funktionalität wird durch betriebssystemspezifische Dateien wie unistd.h für Linux und Windows.h für Windows bereitgestellt.

Um die Funktion sleep() auf einem Linux- oder UNIX-Betriebssystem zu verwenden, müssen wir die Header-Datei "unistd.h" in unser Programm aufnehmen.

Funktionsprototyp

unsigned sleep(unsigned seconds);

Es dauert eine Parametermenge von Sekunden, für die wir die Ausführung aussetzen müssen, und gibt 0 zurück, wenn es erfolgreich zur Ausführung zurückkehrt. Wird der Schlaf zwischendurch unterbrochen, wird die Gesamtzeit abzüglich der Unterbrechungszeit zurückgegeben.

Beispiel:

#ifdef _WIN32
#include <Windows.h>
#else
#include <unistd.h>
#endif
#include <cstdlib>
#include <iostream>
using namespace std;

int main() {
  cout << "Before sleep call " << endl;
  cout.flush();
  sleep(9);
  cout << "After sleep call" << endl;

  return 0;
}

Ausgabe:

Before sleep call
After sleep call

In der Ausgabe haben wir zwei Anweisungen gedruckt. Nach dem Drucken des ersten wartet der Compiler 9 Sekunden und dann wird der andere gedruckt. Leser sollten das Programm ausführen, um diese Verzögerung zu beobachten.

Verwendung der Funktion usleep() zum Hinzufügen einer zeitlichen Verzögerung in C++

Eine weitere Funktion im Header unistd.h ist usleep(), mit der Sie die Ausführung eines Programms für eine bestimmte Zeit pausieren können. Die Bedienung ist identisch mit der zuvor beschriebenen Funktion sleep().

Die Funktion usleep() unterbricht die Ausführung des Aufrufer-Threads für Usekunden Mikrosekunden oder bis das Signal gesendet wird, das die Ausführung unterbricht.

Funktionsprototyp

int usleep(useconds_t useconds);

Diese Funktion übernimmt als Parameter die Anzahl der Mikrosekunden, für die Sie die Ausführung anhalten müssen, und gibt 0 zurück, wenn sie erfolgreich fortgesetzt wird, und -1, wenn ein Fehler auftritt.

Beispiel:

#include <unistd.h>

#include <cstdlib>
#include <iostream>
using namespace std;

int main() {
  cout << "Hello ";
  cout.flush();
  usleep(10000);
  cout << "World";
  cout << endl;

  return 0;
}

Ausgabe:

Before Usleep Call
After Usleep call

Wie Sie im obigen Code-Snippet sehen können, haben wir eine Wartezeit von 10000 Mikrosekunden zwischen dem Drucken von zwei Anweisungen vorgesehen.

In C++ 11 werden uns spezielle Funktionen zur Verfügung gestellt, um Threads in den Ruhezustand zu versetzen. Dazu gibt es zwei Methoden, sleep_for und sleep_until.

Lassen Sie uns diese beiden Methoden besprechen:

Verwendung der Funktion sleep_for() zum Hinzufügen einer zeitlichen Verzögerung in C++

Die Funktion sleep_for () ist im Header <thread> definiert. Die Funktion sleep_for () unterbricht die Ausführung des aktuellen Threads für die in Schlafdauer angegebene Dauer.

Aufgrund von Planungsaktivitäten oder Verzögerungen durch Ressourcenkonflikte kann diese Funktion länger als den angegebenen Zeitraum blockieren.

Funktionsprototyp

template <class Rep, class Period>
void sleep_for(const std::chrono::duration<Rep, Period>& sleep_duration);

Beispiel:

#include <chrono>
#include <iostream>
#include <thread>
using namespace std;

int main() {
  cout << "Hello I'm here before waiting" << endl;
  this_thread::sleep_for(chrono::milliseconds(10000));
  cout << "I Waited for 10000 ms\n";
}

Ausgabe:

Hello I'm here before waiting
I Waited for 10000 ms

Im obigen Codeausschnitt haben wir den Haupt-Thread für 10000 Millisekunden in den Ruhezustand versetzt, was bedeutet, dass der aktuelle Thread 10000 Millisekunden blockiert und dann seine Ausführung wieder aufnimmt.

Verwenden Sie die Funktion sleep_until(), um eine zeitgesteuerte Verzögerung in C++ hinzuzufügen

Der Header <thread> definiert diese Funktion. Die Methode sleep_until () stoppt die Ausführung eines Threads, bis die Ruhezeit abgelaufen ist.

Aufgrund von Planungsaktivitäten oder Verzögerungen durch Ressourcenkonflikte kann diese Funktion wie die anderen länger als die angegebene Zeit blockieren.

Funktionsprototyp

template <class Clock, class Duration>
void sleep_until(const std::chrono::time_point<Clock, Duration>& sleep_time);

Es nimmt als Parameter den Zeitraum an, für den der Thread blockiert werden muss, und gibt nichts zurück.

Beispiel:

#include <chrono>
#include <iostream>
#include <thread>
using namespace std;

int main() {
  cout << "Hello I'm here before waiting" << endl;
  std::this_thread::sleep_until(std::chrono::system_clock::now()
                                    std::chrono::seconds(3));
  cout << "I Waited for 3 seconds\n";
}

Ausgabe:

Hello I'm here before waiting
I Waited for 2 seconds