Como você consegue dormir em c++?

Enquanto um tópico está em execução, é possível que o tópico pare por algum tempo e depois continue correndo novamente. Isso é chamado de dormir. O programador tem que decidir se um tópico precisa ou não dormir. Se o tópico tem que dormir, o programador precisa decidir quando e onde (em que posição da sequência de declarações) o tópico tem que dormir.

A próxima pergunta é: “O que é um tópico?”Um tópico é como um subprograma em um programa C ++. Um programa C ++ simples normal é como um tópico. É a função principal () que é efetivamente o único tópico. A função principal () é uma função de nível superior. Um programa C ++ pode ter outras funções de nível superior. Cada uma das outras funções de nível superior pode ser convertida formalmente em um tópico. A função C ++ Main () se comporta como um thread sem qualquer conversão formal (em um thread).

O espaço para nome padrão C ++ tem a classe estática, this_thread. Esta classe estática tem as funções de membro,

Void Sleep_for (rel_time)

e

Void Sleep_until (ABS_TIME)

Essas funções precedidas por "this_thread ::" podem ser usadas em qualquer tópico, incluindo a função principal (). A função principal () não precisa de nenhuma conversão em um tópico. Cada uma dessas funções pode ser usada para fazer um fio de fio. Cada uma dessas funções leva uma discussão. No entanto, os argumentos são de diferentes tipos.

Sleep_for () usa tempo relativo como argumento, enquanto Sleep_until () usa tempo absoluto como argumento. Rel_time, que significa tempo relativo, é a duração para o fio dormir. Por outro. Nesse caso, o tópico começa a dormir quando a função Sleep_until () é executada.
Time_Point em C ++ é o ponto de tempo após a época da UNIX. A época da UNIX é 1º de janeiro de 1970.

Este artigo explica como fazer um fio de fio. Começa com um resumo de como codificar um tópico. Também explica como fazer um programa simples em C ++, dormir.

Conteúdo do artigo

• Resumo da codificação do thread
• Objetos de tempo relativos e absolutos
• Dormindo por tempo relativo
• Dormindo pelo tempo absoluto
• Conclusão

Resumo da codificação do thread

O programa a seguir possui dois tópicos: um dos quais é a função principal () e o outro é: thr:

#incluir
#incluir
usando namespace std;
void funct ()
cout <<"Code A goes here." <cout <<"Code B goes here." <
int main ()

Thread Thr (funct);
Thr.juntar();
retornar 0;

A saída é:

Código A vai aqui.
Código B vai aqui.

O programa começa com a inclusão da biblioteca iostream. Em seguida, há a inclusão da biblioteca de threads, que é uma obrigação. A próxima linha depois é uma declaração. Esta declaração garante que qualquer nome usado abaixo no programa seja do espaço de nome padrão, a menos que indicado de outra forma. Depois, há a definição da função de nível superior, funct ().

Depois dessa definição, a função principal (). A função principal () também é uma definição de função. A primeira declaração na função Main () instancia o thread, thr. O argumento para o THR é o nome da função de nível superior, funct (). Nesta instanciação, a função, funct () é chamada. O fio efetivo é a função de nível superior. Observe que a função principal (), como um fio, não tem nenhuma declaração formal para um tópico, mas a função, funct () tem.

A próxima declaração na função Main () é a declaração de junção (). Esta afirmação deve estar no corpo da função do tópico de chamada. Se esta declaração estiver ausente, o encadeamento principal () poderá ser concluído sem o thread que se completa. De fato, se essa declaração estiver ausente, o compilador G ++ não compilará o programa e emitirá uma mensagem de erro.

Objetos de tempo relativos e absolutos
Duração, intervalo

A função Sleep_for () toma um objeto de duração como argumento. Este é tempo relativo. Com a inclusão da biblioteca Chrono, os objetos de tempo relativos podem ser criados da seguinte forma:

Chrono :: Hour HS (3);
Chrono :: minutos MS (3);
Chrono :: segundos SS (3);
Chrono :: milissegunds mss (3);
Chrono :: microssegundos Miss (3);

Aqui, há 3 horas com o nome, HS; 3 minutos com o nome, MS; 3 segundos com o nome, SS; 3 milissegundos com o nome, MSS; e 3 microssegundos com o nome, senhorita.

1 milissegundo = 1/1000 segundos. 1 microssegundo = 1/1000000 segundos.

Ponto no tempo

Time_Point em C ++, é o ponto de tempo após a época do UNIX. A época da UNIX é 1º de janeiro de 1970. Este é o tempo absoluto. A função, sleep_until () usa objeto de tempo absoluto como seu argumento. Com a inclusão da biblioteca Chrono, os objetos do tempo absoluto, depois agora, podem ser criados da seguinte forma:

Chrono :: System_clock :: time_point tp = crono :: system_clock :: agora () + crono :: hours (3);
Chrono :: System_clock :: time_point tp = crono :: system_clock :: agora () + crono :: minutos (3);
Chrono :: System_clock :: time_point tp = crono :: system_clock :: agora () + crono :: segundos (3);
Chrono :: System_clock :: time_point tp = crono :: system_clock :: agora () + crono :: milisconds (3);
Chrono :: system_clock :: time_point tp = crono :: system_clock :: agora () + crono :: microssegundos (3);

O nome de cada um desses objetos é tp.

Dormindo por tempo relativo
Função principal

Para dormir por tempo ou duração relativa, a função Sleep_for () deve ser usada, precedida por “this_thread ::” . A duração começa a partir de quando a função é executada. A função principal () é o encadeamento principal, que não precisa de nenhuma declaração. No programa a seguir, a função principal dorme por 1 segundo:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

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

A saída é:

Código A vai aqui.

E depois de um segundo,

Código B vai aqui.

é exibido. Este programa de thread não tem declaração de thread; Porque o thread é a função principal (). Observe que a biblioteca Chrono, assim como a biblioteca de threads, foram incluídos.

A saída é duas cordas da função principal. Entre essas cordas, há o código:

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

Observe como a função do sono foi usada.

Tópico convencional

A explicação para fios convencionais é semelhante à explicação acima, mas o código de tempo está no corpo da linha real. No programa a seguir, o tópico dorme por 1 segundo:

#incluir
#incluir
#incluir
usando namespace std;
void funct ()
cout <<"Code A goes here." <Chrono :: segundos SS (1);
this_thread :: sleep_for (ss);
cout <<"Code B goes here." <
int main ()

Thread Thr (funct);
Thr.juntar();
retornar 0;

A saída é:

Código A vai aqui.

E depois de um segundo,

Código B vai aqui.

é exibido. Existem dois tópicos aqui: o tópico convencional e a função principal (). Observe que a biblioteca Chrono, assim como a biblioteca de threads, foram incluídos.

Saída são duas cordas no corpo da função de rosca convencional. Entre essas cordas, há o código:

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

Observe a relação entre essas duas declarações.

Dormindo pelo tempo absoluto

Para dormir pelo tempo absoluto, a função Sleep_until () deve ser usada, precedida por "this_thread ::" . O tempo começa da época da UNIX para um tempo no futuro. Se o argumento absoluto ou de ponto no tempo for no passado, então seria ignorado. Então, o tópico deve realmente acordar no momento no futuro.

Função principal

A função principal () é o encadeamento principal, que não precisa de nenhuma declaração. No programa a seguir, a função principal dorme até 1 segundo depois de agora, timing a partir de 1º de janeiro de 1970 (UNIX Epoch):

#incluir
#incluir
#incluir
usando namespace std;
int main ()

cout <<"Code A goes here." <Chrono :: System_clock :: time_point tp = crono :: system_clock :: agora () + crono :: segundos (1);
this_thread :: sleep_until (tp);
cout <<"Code B goes here." <retornar 0;

A saída é:

Código A vai aqui.

E depois de um segundo,

Código B vai aqui.

é exibido. Este é um programa de um thread que não tem declaração de threads; Porque o thread é a função principal (). Observe que a biblioteca Chrono, assim como a biblioteca de threads, foram incluídos.

A saída é duas cordas na função principal. Entre essas cordas, há o código:

Chrono :: System_clock :: time_point tp = crono :: system_clock :: agora () + crono :: segundos (1);
this_thread :: sleep_until (tp);

Observe como a função do sono foi usada

Tópico convencional

A explicação para fios convencionais é semelhante à explicação acima, mas o código de tempo está no corpo da linha real. No programa a seguir, o tópico dorme até 1 segundo depois de agora:

#incluir
#incluir
#incluir
usando namespace std;
void funct ()
cout << "Code A goes here." <Chrono :: System_clock :: time_point tp = crono :: system_clock :: agora () + crono :: segundos (1);
this_thread :: sleep_until (tp);
cout << "Code B goes here." <
int main ()

Thread Thr (funct);
Thr.juntar();
retornar 0;

A saída é:

Código A vai aqui.

E depois de um segundo,

Código B vai aqui.

é exibido. Existem dois tópicos aqui: o tópico convencional e a função principal (). Observe que a biblioteca Chrono, assim como a biblioteca de threads, foram incluídos.

A saída é duas cordas no corpo da função de rosca convencional. Entre essas cordas, há o código:

Chrono :: System_clock :: time_point tp = crono :: system_clock :: agora () + crono :: segundos (1);
this_thread :: sleep_until (tp);

Observe a relação entre essas duas declarações.

Conclusão

Um tópico pode ser feito para dormir por uma duração ou dormir e acordar em um momento futuro desde a época do Unix. Para dormir por um duração, use a função Sleep_for (). Para dormir e acordar, use a função Sleep_until (). Cada uma dessas funções deve ser precedida por isso, “this_thread ::”. Um programa C ++ simples normal é um programa encadeado. O tópico aqui é a função principal () e não precisa de declaração de thread.