Come si ottiene il sonno in C++?

Mentre un thread è in esecuzione, è possibile che il thread si fermi per un po 'di tempo e quindi continui a funzionare di nuovo. Questo si chiama dormire. Il programmatore deve decidere se un thread deve dormire o meno. Se il thread deve dormire, il programmatore deve decidere quando e dove (in quale posizione della sequenza di istruzioni) il thread deve dormire.

La prossima domanda è: “Cos'è un thread?"Un thread è come un sottoprogramma in un programma C ++. Un normale programma C ++ semplice è come un thread. È la funzione principale () che è effettivamente un thread. La funzione principale () è una funzione di alto livello. Un programma C ++ può avere altre funzioni di alto livello. Ciascuna delle altre funzioni di alto livello può essere convertita formalmente in un thread. La funzione C ++ main () si comporta come un thread senza alcuna conversione formale (in un thread).

Lo spazio dei nomi standard C ++ ha la classe statica, this_thread. Questa classe statica ha le funzioni del membro,

void sleep_for (rel_time)

E

void sleep_untl (ABS_Time)

Queste funzioni precedute da "this_thread ::" possono essere utilizzate in qualsiasi thread, inclusa la funzione principale (). La funzione principale () non richiede alcuna conversione in un thread. Ognuna di queste funzioni può essere utilizzata per far dormire un filo. Ognuna di queste funzioni prende un argomento. Tuttavia, gli argomenti sono di diversi tipi.

sleep_for () usa il tempo relativo come argomento, mentre sleep_unt () usa il tempo assoluto come argomento. rel_time, che significa tempo relativo, è la durata per il sonno. D'altra parte, con Abs_time, che significa assoluta_time, per la funzione sleep_unt (), ABS_time è il punto temporale quando il thread si sveglierà dal sonno. In questo caso, il thread inizia a dormire quando viene eseguita la funzione sleep_unt ().
Time_point in c ++ è il punto temporale dopo l'epoca unix. L'epoca unix è il 1 ° gennaio 1970.

Questo articolo spiega come far dormire un thread. Inizia con un riepilogo di come codificare un thread. Spiega anche come creare un semplice programma in C ++, Sleep.

Contenuto dell'articolo

• Riepilogo della codifica del thread
• Oggetti temporali relativi e assoluti
• Dormire al tempo relativo
• Dormire in tempo assoluto
• Conclusione

Riepilogo della codifica del thread

Il seguente programma ha due thread: uno dei quali è la funzione principale () e l'altro è, Thr:

#includere
#includere
Utilizzo dello spazio dei nomi std;
void funct ()
cout <<"Code A goes here." <cout <<"Code B goes here." <
int main ()

Thread Thr (funct);
thr.giuntura();
restituzione 0;

L'output è:

Il codice A va qui.
Il codice B va qui.

Il programma inizia con l'inclusione della libreria iostream. Successivamente, c'è l'inclusione della libreria di thread, che è un must. La riga successiva dopo è una dichiarazione. Questa affermazione garantisce che qualsiasi nome utilizzato sotto di essa nel programma sia dello spazio dei nomi standard se non diversamente indicato. Quindi c'è la definizione della funzione di alto livello, funct ().

Dopo questa definizione è la funzione principale (). La funzione principale () è anche una definizione di funzione. La prima istruzione nella funzione principale () istanzia il thr, thr. L'argomento a THR è il nome della funzione di alto livello, funct (). In questa istanza, la funzione, funct () è chiamata. Il thread efficace è la funzione di livello superiore. Si noti che la funzione principale (), come un thread, non ha alcuna dichiarazione formale per un thread, ma la funzione, funct () ha.

L'istruzione successiva nella funzione principale () è l'istruzione join (). Questa affermazione deve essere nel corpo della funzione del thread chiamante. Se questa istruzione è assente, il thread principale () può essere eseguito fino al completamento senza che il thre thr si completa. In effetti, se questa affermazione è assente, il compilatore G ++ non compilerà il programma e emetterà un messaggio di errore.

Oggetti temporali relativi e assoluti
Durata, intervallo

La funzione sleep_for () prende un oggetto di durata come argomento. Questo è il tempo relativo. Con l'inclusione della libreria Chrono, gli oggetti del tempo relativo possono essere creati come segue:

Chrono :: Hours HS (3);
Chrono :: minuti MS (3);
Chrono :: Seconds SS (3);
Chrono :: millisecondi MSS (3);
Chrono :: Microseconds Miss (3);

Qui, ci sono 3 ore con il nome, HS; 3 minuti con il nome, MS; 3 secondi con il nome, SS; 3 millisecondi con il nome, MSS; e 3 microsecondi con il nome, signorina.

1 millisecondo = 1/1000 secondi. 1 microsecondo = 1/1000000 secondi.

Punto temporale

Time_point in c ++, è il punto temporale dopo l'epoca unix. L'epoca unix è il 1 ° gennaio 1970. Questo è tempo assoluto. La funzione, sleep_until () usa l'oggetto tempo assoluto come argomento. Con l'inclusione della libreria Chrono, gli oggetti temporali assoluti, dopo ora, possono essere creati come segue:

Chrono :: System_Clock :: time_point tp = Chrono :: System_Clock :: Now () + Chrono :: Hours (3);
Chrono :: System_Clock :: time_point tp = Chrono :: System_Clock :: Now () + Chrono :: Minutes (3);
Chrono :: System_Clock :: time_point tp = Chrono :: System_Clock :: Now () + Chrono :: Seconds (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 :: Microseconds (3);

Il nome di ciascuno di questi oggetti è TP.

Dormire al tempo relativo
Funzione principale

Per dormire per tempo o durata relativi, la funzione sleep_for () deve essere usata, preceduta da "this_thread ::" . La durata inizia da quando viene eseguita la funzione. La funzione principale () è il thread principale, che non ha bisogno di alcuna dichiarazione. Nel seguente programma, la funzione principale dorme per 1 secondo:

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

cout <<"Code A goes here." <Chrono :: Seconds SS (1);
this_thread :: sleep_for (ss);
cout <<"Code B goes here." <restituzione 0;

L'output è:

Il codice A va qui.

e dopo un secondo,

Il codice B va qui.

È visualizzato. Questo programma di thread non ha una dichiarazione di thread; Perché il thread è la funzione principale (). Si noti che la libreria Chrono, così come la libreria di thread, sono state incluse.

L'output è due stringhe dalla funzione principale. Tra queste stringhe, c'è il codice:

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

Nota come è stata utilizzata la funzione del sonno.

Filione convenzionale

La spiegazione per i thread convenzionali, è simile alla spiegazione sopra, ma il codice di temporizzazione è nel corpo effettivo del thread. Nel seguente programma, il thread dorme per 1 secondo:

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
void funct ()
cout <<"Code A goes here." <Chrono :: Seconds SS (1);
this_thread :: sleep_for (ss);
cout <<"Code B goes here." <
int main ()

Thread Thr (funct);
thr.giuntura();
restituzione 0;

L'output è:

Il codice A va qui.

e dopo un secondo,

Il codice B va qui.

È visualizzato. Ci sono due thread qui: il thread convenzionale e la funzione principale (). Si noti che la libreria Chrono, così come la libreria di thread, sono state incluse.

L'uscita sono due stringhe nel corpo convenzionale della funzione thread. Tra queste stringhe, c'è il codice:

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

Nota la relazione tra queste due affermazioni.

Dormire in tempo assoluto

Per dormire per tempo assoluto, la funzione sleep_unt () deve essere usata, preceduta da "this_thread ::" . Il tempo inizia dall'epoca unix a un tempo in futuro. Se l'argomento assoluto o time-point è in passato, allora verrebbe ignorato. Quindi, il thread dovrebbe effettivamente svegliarsi al momento in futuro.

Funzione principale

La funzione principale () è il thread principale, che non ha bisogno di alcuna dichiarazione. Nel seguente programma, la funzione principale dorme fino a 1 secondo dopo ora, i tempi del 1 ° gennaio 1970 (Epoca UNIX):

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

cout <<"Code A goes here." <Chrono :: System_Clock :: time_point tp = Chrono :: System_Clock :: Now () + Chrono :: Seconds (1);
this_thread :: sleep_unt (tp);
cout <<"Code B goes here." <restituzione 0;

L'output è:

Il codice A va qui.

e dopo un secondo,

Il codice B va qui.

È visualizzato. Questo è un programma a un thread che non ha una dichiarazione di thread; Perché il thread è la funzione principale (). Si noti che la libreria Chrono, così come la libreria di thread, sono state incluse.

L'output è due stringhe nella funzione principale. Tra queste stringhe, c'è il codice:

Chrono :: System_Clock :: time_point tp = Chrono :: System_Clock :: Now () + Chrono :: Seconds (1);
this_thread :: sleep_unt (tp);

Nota come è stata utilizzata la funzione del sonno

Filione convenzionale

La spiegazione per i thread convenzionali, è simile alla spiegazione sopra, ma il codice di temporizzazione è nel corpo effettivo del thread. Nel seguente programma, il thread dorme fino a 1 secondo dopo ora:

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
void funct ()
cout << "Code A goes here." <Chrono :: System_Clock :: time_point tp = Chrono :: System_Clock :: Now () + Chrono :: Seconds (1);
this_thread :: sleep_unt (tp);
cout << "Code B goes here." <
int main ()

Thread Thr (funct);
thr.giuntura();
restituzione 0;

L'output è:

Il codice A va qui.

e dopo un secondo,

Il codice B va qui.

È visualizzato. Ci sono due thread qui: il thread convenzionale e la funzione principale (). Si noti che la libreria Chrono, così come la libreria di thread, sono state incluse.

L'output è due stringhe nel corpo della funzione thread convenzionale. Tra queste stringhe, c'è il codice:

Chrono :: System_Clock :: time_point tp = Chrono :: System_Clock :: Now () + Chrono :: Seconds (1);
this_thread :: sleep_unt (tp);

Nota la relazione tra queste due affermazioni.

Conclusione

Un filo può essere fatto dormire per una durata o dormire e svegliarsi in futuro dall'epoca unix. Per dormire per una durata, usa la funzione sleep_for (). Per dormire e svegliarsi, usa la funzione sleep_until (). Ognuna di queste funzioni deve essere preceduta da questo, "this_thread ::". Un normale programma C ++ semplice è un programma filettato. Il thread qui è la funzione principale () e non richiede alcuna dichiarazione di thread.