Wie erhalten Sie Schlaf in C++?

Während ein Thread läuft, kann der Thread einige Zeit anhalten und dann weiter laufen. Dies wird als Schlaf bezeichnet. Der Programmierer muss entscheiden, ob ein Thread schlafen muss oder nicht. Wenn der Faden schlafen muss, muss der Programmierer entscheiden, wann und wo (in welcher Position der Abfolge von Aussagen) der Faden schlafen muss.

Die nächste Frage ist: „Was ist ein Thread?”Ein Thread ist wie ein Unterprogramm in einem C ++-Programm. Ein normales einfaches C ++ - Programm ist wie ein Thread. Es ist die main () -Funktion, die effektiv der eine Thread ist. Die Funktion main () ist eine Funktion auf der obersten Ebene. Ein C ++-Programm kann andere Funktionen auf höchster Ebene haben. Jede der anderen Funktionen auf der oberen Ebene kann formell in einen Faden umgewandelt werden. Die Funktion c ++ main () verhält sich wie ein Thread ohne formale Umwandlung (in einen Thread).

Der C ++-Standard-Namespace hat die statische Klasse, dieses_Thread. Diese statische Klasse hat die Mitgliedsfunktionen,

void sleep_for (rel_time)

Und

void sleep_until (ABS_Time)

Diese Funktionen, denen „This_Thread ::“ vorausging, kann in jedem Thread verwendet werden, einschließlich der Funktion main (). Die Funktion main () benötigt keine Konvertierung in einen Thread. Jede dieser Funktionen kann verwendet werden, um einen Fadenschlaf zu machen. Jede dieser Funktionen nimmt ein Argument an. Die Argumente sind jedoch unterschiedliche Typen.

sleep_for () nutzt die relative Zeit als Argument, während sleep_until () die absolute Zeit als Argument verwendet. rel_time, was die relative Zeit bedeutet, ist die Dauer, in der der Faden schlafen kann. Auf der anderen Seite ist ABS_Time, was Absolute_Time bedeutet, für die Funktion sleep_until () ABS_Time der Zeitpunkt, wenn der Thread aus dem Schlaf aufwacht. In diesem Fall beginnt der Faden zu schlafen, wenn die Funktion sleep_until () ausgeführt wird.
Time_point in c ++ ist der Zeitpunkt nach der UNIX -Epoche. Die Unix -Epoche ist der 1. Januar 1970.

In diesem Artikel wird erläutert, wie man einen Fadenschlaf macht. Es beginnt mit einer Zusammenfassung, wie man einen Thread codiert. Es erklärt auch, wie man ein einfaches Programm in C ++, Schlaf, erstellt.

Artikelinhalt

• Zusammenfassung der Thread -Codierung
• Relative und absolute Zeitobjekte
• Nach relativer Zeit schlafen
• Durch absolute Zeit schlafen
• Abschluss

Zusammenfassung der Thread -Codierung

Das folgende Programm enthält zwei Threads: eine davon ist die Haupt- () -Funktion, und das andere ist: Thr:

#enthalten
#enthalten
Verwenden von Namespace STD;
void funct ()
Cout <<"Code A goes here." <Cout <<"Code B goes here." <
int main ()

thread thr (funk);
TH.verbinden();
Rückkehr 0;

Die Ausgabe ist:

Code A geht hierher.
Code B geht hierher.

Das Programm beginnt mit der Aufnahme der iostream -Bibliothek. Als nächstes gibt es die Einbeziehung der Thread -Bibliothek, die ein Muss ist. Die nächste Zeile danach ist eine Aussage. Diese Erklärung stellt sicher, dass ein beliebiger Name unten im Programm der Standard -Namespace ist, sofern nicht anders angegeben. Dann gibt es die Definition der obersten Funktion, funct ().

Nach dieser Definition ist die main () -Funktion. Die Funktion main () ist auch eine Funktionsdefinition. Die erste Aussage in der Funktion main () instanziiert den Thread THR. Das Argument für THR ist der Name der oberen Funktionsfunktion, Funct (). In dieser Instanziierung wird die Funktion funct () genannt. Der effektive Faden ist die obere Funktionsfunktion. Beachten.

Die nächste Anweisung in der Funktion main () ist die Anweisung join () ist. Diese Aussage muss im Funktionskörper des aufrufenden Threads liegen. Wenn diese Aussage nicht vorhanden ist, kann der Main () -Thread abgeschlossen werden, ohne dass der Thread Thr selbst abgeschlossen ist. Wenn diese Aussage nicht vorhanden ist, erstellt der G ++ - Compiler das Programm nicht und gibt eine Fehlermeldung aus.

Relative und absolute Zeitobjekte
Dauer, Intervall

Die Funktion sleep_for () nimmt ein Dauerobjekt als Argument an. Dies ist relative Zeit. Mit der Einbeziehung der Chrono -Bibliothek können die relativen Zeitobjekte wie folgt erstellt werden:

Chrono :: Stunden HS (3);
Chrono :: Minuten MS (3);
Chrono :: Sekunden SS (3);
Chrono :: Milliseconds MSS (3);
Chrono :: Mikrosekunden Miss (3);

Hier gibt es 3 Stunden mit dem Namen HS; 3 Minuten mit dem Namen, MS; 3 Sekunden mit dem Namen, SS; 3 Millisekunden mit dem Namen, MSS; und 3 Mikrosekunden mit dem Namen, Miss.

1 Millisekunden = 1/1000 Sekunden. 1 Mikrosekunde = 1/1000000 Sekunden.

Zeitpunkt

Time_point in c ++ ist der Zeitpunkt nach der UNIX -Epoche. Die Unix -Epoche ist der 1. Januar 1970. Das ist absolute Zeit. Die Funktion Sleep_until () verwendet absolutes Zeitobjekt als Argument. Mit der Einbeziehung der Chrono -Bibliothek können die absoluten Zeitobjekte danach wie folgt erstellt werden:

chrono :: system_clock :: time_point tp = chrono :: system_clock :: now () + Chrono :: Stunden (3);
chrono :: system_clock :: time_point tp = chrono :: system_clock :: now () + chrono :: minute (3);
Chrono :: System_clock :: time_point tp = Chrono :: System_clock :: Now () + Chrono :: Sekunden (3);
chrono :: system_clock :: time_point tp = chrono :: system_clock :: now () + chrono :: milliseconds (3);
Chrono :: System_clock :: time_point tp = chrono :: system_clock :: now () + chrono :: microseseconds (3);

Der Name jedes dieser Objekte ist TP.

Nach relativer Zeit schlafen
Hauptfunktion

Um nach relativer Zeit oder Dauer zu schlafen, muss die Funktion sleep_for () verwendet werden, die „this_thread ::“ vorausging . Die Dauer beginnt von der Ausführung der Funktion. Die Funktion main () ist der Hauptfaden, der keine Deklaration benötigt. Im folgenden Programm schläft die Hauptfunktion 1 Sekunde:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Cout <<"Code A goes here." <Chrono :: Sekunden SS (1);
this_thread :: sleep_for (ss);
Cout <<"Code B goes here." <Rückkehr 0;

Die Ausgabe ist:

Code A geht hierher.

und nach einer Sekunde,

Code B geht hierher.

wird angezeigt. Dieses eine Thread -Programm hat keine Thread -Deklaration; Weil der Faden die main () -Funktion ist. Beachten Sie, dass die Chrono -Bibliothek sowie die Thread -Bibliothek enthalten sind.

Ausgang ist zwei Zeichenfolgen aus der Hauptfunktion. Zwischen diesen Saiten gibt es den Code:

Chrono :: Sekunden SS (1);
this_thread :: sleep_for (ss);

Beachten Sie, wie die Schlaffunktion verwendet wurde.

Konventioneller Faden

Die Erklärung für herkömmliche Threads ähnelt der obigen Erklärung, aber der Timing -Code befindet sich im tatsächlichen Thread -Körper. Im folgenden Programm schläft der Thread 1 Sekunde:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
void funct ()
Cout <<"Code A goes here." <Chrono :: Sekunden SS (1);
this_thread :: sleep_for (ss);
Cout <<"Code B goes here." <
int main ()

thread thr (funk);
TH.verbinden();
Rückkehr 0;

Die Ausgabe ist:

Code A geht hierher.

und nach einer Sekunde,

Code B geht hierher.

wird angezeigt. Hier gibt es zwei Threads: den herkömmlichen Thread und die Main () -Funktion. Beachten Sie, dass die Chrono -Bibliothek sowie die Thread -Bibliothek enthalten sind.

Ausgang sind zwei Zeichenfolgen im konventionellen Fadenfunktionskörper. Zwischen diesen Saiten gibt es den Code:

Chrono :: Sekunden SS (1);
this_thread :: sleep_for (ss);

Beachten Sie die Beziehung zwischen diesen beiden Aussagen.

Durch absolute Zeit schlafen

Um nach absoluter Zeit zu schlafen, muss die Funktion sleep_until () verwendet werden, vorausgesetzt, „This_Thread ::“ . Die Zeit beginnt von der Unix -Epoche bis zu einer Zeit in der Zukunft. Wenn das Absolut- oder Zeitpunktargument in der Vergangenheit ist, würde es ignoriert werden. Der Thread sollte also zum Zeitpunkt der Zukunft tatsächlich aufwachen.

Hauptfunktion

Die Funktion main () ist der Hauptfaden, der keine Deklaration benötigt. Im folgenden Programm schläft die Hauptfunktion bis 1 Sekunde nach dem Timing ab dem 1. Januar 1970 (UNIX -Epoche):

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Cout <<"Code A goes here." <Chrono :: System_clock :: TIME_POINT TP = Chrono :: System_Clock :: Now () + Chrono :: Sekunden (1);
this_thread :: sleep_until (tp);
Cout <<"Code B goes here." <Rückkehr 0;

Die Ausgabe ist:

Code A geht hierher.

und nach einer Sekunde,

Code B geht hierher.

wird angezeigt. Dies ist ein Ein-Thread-Programm, das keine Thread-Erklärung enthält. Weil der Faden die main () -Funktion ist. Beachten Sie, dass die Chrono -Bibliothek sowie die Thread -Bibliothek enthalten sind.

Die Ausgabe ist zwei Zeichenfolgen in der Hauptfunktion. Zwischen diesen Saiten gibt es den Code:

Chrono :: System_clock :: TIME_POINT TP = Chrono :: System_Clock :: Now () + Chrono :: Sekunden (1);
this_thread :: sleep_until (tp);

Beachten Sie, wie die Schlaffunktion verwendet wurde

Konventioneller Faden

Die Erklärung für herkömmliche Threads ähnelt der obigen Erklärung, aber der Timing -Code befindet sich im tatsächlichen Thread -Körper. Im folgenden Programm schläft der Faden bis 1 Sekunde nach jetzt:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
void funct ()
Cout << "Code A goes here." <Chrono :: System_clock :: TIME_POINT TP = Chrono :: System_Clock :: Now () + Chrono :: Sekunden (1);
this_thread :: sleep_until (tp);
Cout << "Code B goes here." <
int main ()

thread thr (funk);
TH.verbinden();
Rückkehr 0;

Die Ausgabe ist:

Code A geht hierher.

und nach einer Sekunde,

Code B geht hierher.

wird angezeigt. Hier gibt es zwei Threads: den herkömmlichen Thread und die Main () -Funktion. Beachten Sie, dass die Chrono -Bibliothek sowie die Thread -Bibliothek enthalten sind.

Die Ausgabe besteht aus zwei Zeichenfolgen im konventionellen Fadenfunktionskörper. Zwischen diesen Saiten gibt es den Code:

Chrono :: System_clock :: TIME_POINT TP = Chrono :: System_Clock :: Now () + Chrono :: Sekunden (1);
this_thread :: sleep_until (tp);

Beachten Sie die Beziehung zwischen diesen beiden Aussagen.

Abschluss

Ein Faden kann für eine Dauer oder einen Schlaf geschlafen werden und aufwachen zu einer zukünftigen Zeit seit der Unix -Epoche aufwachen. Verwenden Sie die Funktion Sleep_for (), um für eine Dauer für eine Dauer zu schlafen. Verwenden Sie die Funktion sleep_until (), um zu schlafen und aufzuwachen. Jede dieser Funktionen muss dieser "This_Thread ::" vorausgehen. Ein normales einfaches C ++ - Programm ist ein Thread -Programm. Der Thread hier ist die main () -Funktion und benötigt keine Thread -Deklaration.