Jak zdobyć sen w C++?

Podczas gdy wątek działa, wątek może się zatrzymać na jakiś czas, a następnie kontynuować bieganie. To się nazywa spanie. Programista musi zdecydować, czy wątek musi spać. Jeśli wątek musi spać, programista musi zdecydować, kiedy i gdzie (w jakiej pozycji sekwencji instrukcji) wątek musi spać.

Następne pytanie brzmi: „Co to jest wątek?„Wątek jest jak podprogram w programie C ++. Normalny prosty program C ++ jest jak jeden wątek. Jest to funkcja main (), która jest skutecznie jednym wątkiem. Funkcja main () to funkcja najwyższego poziomu. Program C ++ może mieć inne funkcje najwyższego poziomu. Każda z pozostałych funkcji najwyższego poziomu można formalnie przekonwertować na wątek. Funkcja C ++ main () zachowuje się jak wątek bez żadnej formalnej konwersji (w wątek).

Standardowa przestrzeń nazw C ++ ma klasę statyczną, this_thread. Ta klasa statyczna ma funkcje członka,

void sleep_for (rel_time)

I

void sleep_until (ABS_TIME)

Funkcje te poprzedzone przez „this_thread ::” można użyć w dowolnym wątku, w tym funkcji main (). Funkcja main () nie wymaga żadnej konwersji w wątek. Każda z tych funkcji można użyć do snu wątku. Każda z tych funkcji przyjmuje argument. Jednak argumenty są różnych typów.

sleep_for () używa czasu względnego jako argumentu, podczas gdy sleep_until () używa czasu absolutnego jako argumentu. rel_time, co oznacza czas względny, jest czas trwania wątku do snu. Z drugiej strony, z ABS_Time, co oznacza Absolute_Time, dla funkcji sleep_until (), ABS_Time to punkt czasowy, gdy wątek obudzi się ze snu. W tym przypadku wątek zaczyna spać, gdy funkcja sleep_until () jest wykonywana.
Time_point w C ++ to punkt czasowy po epokach UNIX. Epoch Unix to 1 stycznia 1970 roku.

W tym artykule wyjaśniono, jak zrobić wątek. Zaczyna się od podsumowania, jak kodować wątek. Wyjaśnia także, jak stworzyć prosty program w C ++, spać.

Treść artykułu

• Podsumowanie kodowania wątków
• Względne i bezwzględne obiekty czasu
• Spanie według względnego czasu
• Spanie w czasie absolutnego
• Wniosek

Podsumowanie kodowania wątków

Poniższy program zawiera dwa wątki: jeden z nich jest funkcją main (), a druga to, thr:

#włączać
#włączać
za pomocą przestrzeni nazw Std;
void funct ()
Cout <<"Code A goes here." <Cout <<"Code B goes here." <
int main ()

Thread Thr (FUNCT);
thr.dołączyć();
powrót 0;

Wyjście to:

Kod A idzie tutaj.
Kod B idzie tutaj.

Program zaczyna się od włączenia biblioteki iostream. Następnie jest włączenie biblioteki wątków, co jest koniecznością. Następny wiersz po stwierdzeniu jest. To stwierdzenie zapewnia, że ​​każda nazwa użyta poniżej w programie jest standardowej przestrzeni nazwy, chyba że wskazano inaczej. Następnie istnieje definicja funkcji najwyższego poziomu, funct ().

Po tej definicji jest funkcja Main (). Funkcja main () jest również definicją funkcji. Pierwsza instrukcja w funkcji main () tworzy instancję wątku, thr. Argumentem do Thr jest nazwa funkcji najwyższego poziomu, funct (). W tej instancji nazywana jest funkcja, funct (). Efektywny wątek to funkcja najwyższego poziomu. Zauważ, że funkcja main (), podobnie jak wątek, nie ma żadnej formalnej deklaracji dla wątku, ale funkcja, funct ().

Następnym instrukcją w funkcji main () jest instrukcja łącza (). To stwierdzenie musi znajdować się w organu funkcyjnym wątku wywołującego. Jeśli to stwierdzenie jest nieobecne, wątek main () może działać do zakończenia bez ukończenia wątku. W rzeczywistości, jeśli to stwierdzenie jest nieobecne, kompilator G ++ nie skompiluje programu i wyda komunikat o błędzie.

Względne i bezwzględne obiekty czasu
Czas trwania, przedział

Funkcja sleep_for () przyjmuje obiekt czasu trwania jako argument. To jest czas względny. Dzięki włączeniu biblioteki Chrono względne obiekty czasu można utworzyć w następujący sposób:

Chrono :: godziny HS (3);
Chrono :: Minuty MS (3);
Chrono :: sekundy SS (3);
Chrono :: Miliseconds MSS (3);
Chrono :: Microsekunds Miss (3);

Tutaj są 3 godziny z nazwą, HS; 3 minuty z nazwą, MS; 3 sekundy z nazwą, SS; 3 milisekundy z nazwą, MSS; i 3 mikrosekundy o nazwie, Miss.

1 milisekund = 1/1000 sekund. 1 mikrosekund = 1/1000000 sekund.

Punkt czasowy

Punkt czasowy w C ++, to punkt czasowy po epokach Unix. Epoch Unix to 1 stycznia 1970 roku. To jest czas absolutny. Funkcja, sleep_until () używa obiektu czasowego bezwzględnego jako argumentu. Dzięki włączeniu biblioteki Chrono obiekty czasowe absolutnego czasu mogą być utworzone w następujący sposób:

Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: godziny (3);
Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: minuty (3);
Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: sekundy (3);
Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: milisekunds (3);
Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: Microsekunds (3);

Nazwa każdego z tych obiektów to TP.

Spanie według względnego czasu
Główna funkcja

Aby spać według względnego czasu lub czasu trwania, należy użyć funkcji sleep_for (), poprzedzonej „this_thread ::” . Czas trwania rozpoczyna się od momentu wykonywania funkcji. Funkcja main () jest głównym wątkiem, który nie wymaga żadnej deklaracji. W poniższym programie główna funkcja śpi przez 1 sekundę:

#włączać
#włączać
#włączać
za pomocą przestrzeni nazw Std;
int main ()

Cout <<"Code A goes here." <Chrono :: sekundy SS (1);
this_thread :: sleep_for (ss);
Cout <<"Code B goes here." <powrót 0;

Wyjście to:

Kod A idzie tutaj.

i po jednej sekundzie,

Kod B idzie tutaj.

jest wyświetlany. Ten program jednego wątku nie ma deklaracji wątków; Ponieważ wątek jest funkcją Main (). Zauważ, że biblioteka Chrono, a także biblioteka wątków, zostały uwzględnione.

Wyjście to dwa ciągi z głównej funkcji. Pomiędzy tymi ciągami jest kod:

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

Zwróć uwagę, jak zastosowano funkcję snu.

Konwencjonalny wątek

Wyjaśnienie konwencjonalnych wątków jest podobne do powyższego wyjaśnienia, ale kod czasowy znajduje się w rzeczywistym korpusie wątków. W poniższym programie wątek śpi przez 1 sekundę:

#włączać
#włączać
#włączać
za pomocą przestrzeni nazw Std;
void funct ()
Cout <<"Code A goes here." <Chrono :: sekundy SS (1);
this_thread :: sleep_for (ss);
Cout <<"Code B goes here." <
int main ()

Thread Thr (FUNCT);
thr.dołączyć();
powrót 0;

Wyjście to:

Kod A idzie tutaj.

i po jednej sekundzie,

Kod B idzie tutaj.

jest wyświetlany. Są tutaj dwa wątki: funkcja konwencjonalna i funkcja main (). Zauważ, że biblioteka Chrono, a także biblioteka wątków, zostały uwzględnione.

Wyjście to dwa ciągi w konwencjonalnym korpusie funkcji nici. Pomiędzy tymi ciągami jest kod:

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

Zwróć uwagę na związek między tymi dwoma stwierdzeniami.

Spanie w czasie absolutnego

Aby spać w czasie absolutnego, należy użyć funkcji sleep_until (), poprzedzonej przez „this_thread ::” . Czas zaczyna się od epoki unix do czasu w przyszłości. Jeśli argument bezwzględny lub czasowy jest w przeszłości, zostałby zignorowany. Tak więc wątek powinien faktycznie obudzić się w czasie w przyszłości.

Główna funkcja

Funkcja main () jest głównym wątkiem, który nie wymaga żadnej deklaracji. W poniższym programie główna funkcja śpi do 1 sekundy, czas od 1 stycznia 1970 r. (UNIX EPOCH):

#włączać
#włączać
#włączać
za pomocą przestrzeni nazw Std;
int main ()

Cout <<"Code A goes here." <Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: sekundy (1);
this_thread :: sleep_until (tp);
Cout <<"Code B goes here." <powrót 0;

Wyjście to:

Kod A idzie tutaj.

i po jednej sekundzie,

Kod B idzie tutaj.

jest wyświetlany. Jest to program jednontemu, który nie ma deklaracji wątków; Ponieważ wątek jest funkcją Main (). Zauważ, że biblioteka Chrono, a także biblioteka wątków, zostały uwzględnione.

Wyjście to dwa ciągi w głównej funkcji. Pomiędzy tymi ciągami jest kod:

Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: sekundy (1);
this_thread :: sleep_until (tp);

Zwróć uwagę, jak zastosowano funkcję snu

Konwencjonalny wątek

Wyjaśnienie konwencjonalnych wątków jest podobne do powyższego wyjaśnienia, ale kod czasowy znajduje się w rzeczywistym korpusie wątków. W poniższym programie wątek śpi do 1 sekundy po teraz:

#włączać
#włączać
#włączać
za pomocą przestrzeni nazw Std;
void funct ()
Cout << "Code A goes here." <Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: sekundy (1);
this_thread :: sleep_until (tp);
Cout << "Code B goes here." <
int main ()

Thread Thr (FUNCT);
thr.dołączyć();
powrót 0;

Wyjście to:

Kod A idzie tutaj.

i po jednej sekundzie,

Kod B idzie tutaj.

jest wyświetlany. Są tutaj dwa wątki: funkcja konwencjonalna i funkcja main (). Zauważ, że biblioteka Chrono, a także biblioteka wątków, zostały uwzględnione.

Wyjście to dwa ciągi w konwencjonalnym korpusie funkcji nici. Pomiędzy tymi ciągami jest kod:

Chrono :: System_clock :: Time_point tp = chrono :: System_clock :: now () + chrono :: sekundy (1);
this_thread :: sleep_until (tp);

Zwróć uwagę na związek między tymi dwoma stwierdzeniami.

Wniosek

Nić można spać na czas lub spać i obudzić się w przyszłości od czasu epoki UNIX. Spać przez czas trwania, użyj funkcji sleep_for (). Aby spać i obudzić się, użyj funkcji sleep_until (). Każda z tych funkcji musi być poprzedzona „this_thread ::”. Normalny prosty program C ++ to jeden program do wątku. Wątek tutaj jest funkcją main () i nie wymaga deklaracji wątku.