Comment obtenir le sommeil en C++?

Pendant qu'un fil est en cours d'exécution, il est possible que le fil s'arrête pendant un certain temps et continue ensuite de fonctionner. C'est ce qu'on appelle dormir. Le programmeur doit décider si un fil doit dormir ou non. Si le fil doit dormir, le programmeur doit décider quand et où (à quelle position de la séquence des déclarations), le fil doit dormir.

La question suivante est: «Qu'est-ce qu'un fil?"Un fil est comme un sous-programme dans un programme C ++. Un programme C ++ simple normal est comme un thread. C'est la fonction principale () qui est effectivement le seul thread. La fonction Main () est une fonction de niveau supérieur. Un programme C ++ peut avoir d'autres fonctions de niveau supérieur. Chacune des autres fonctions de niveau supérieur peut être convertie formellement en fil. La fonction C ++ Main () se comporte comme un fil sans conversion formelle (en thread).

L'espace de noms standard C ++ a la classe de type statique, This_thread. Cette classe de type statique a les fonctions des membres,

void sleep_for (rel_time)

et

void sleep_until (ABS_time)

Ces fonctions précédées de «this_thread ::» peuvent être utilisées dans n'importe quel thread, y compris la fonction principale (). La fonction principale () n'a pas besoin de conversion en fil. Chacune de ces fonctions peut être utilisée pour faire dormir un fil. Chacune de ces fonctions prend un argument. Cependant, les arguments sont de différents types.

sleep_for () utilise le temps relatif comme argument, tandis que Sleep_until () utilise le temps absolu comme argument. rel_time, ce qui signifie un temps relatif, est la durée pour que le fil endorme. D'un autre côté, avec ABS_TIME, ce qui signifie absolu_time, pour la fonction sleep_until (), ABS_Time est le temps où le fil se réveillera du sommeil. Dans ce cas, le thread commence à dormir lorsque la fonction sleep_until () est exécutée.
Time_point en C ++ est le point de temps après l'époque Unix. L'Epoch Unix est le 1er janvier 1970.

Cet article explique comment faire dormir un fil. Il commence par un résumé de la façon de coder un fil. Il explique également comment faire un programme simple en C ++, sommeil.

Contenu de l'article

• Résumé du codage du thread
• Objets temporels relatifs et absolus
• Dormir par temps relatif
• Dormir par le temps absolu
• Conclusion

Résumé du codage du thread

Le programme suivant a deux threads: dont l'une est la fonction principale (), et l'autre est, thr:

#inclure
#inclure
Utilisation de Namespace Std;
void funct ()
couter <<"Code A goes here." <couter <<"Code B goes here." <
int main()

thread thr (funct);
thr.rejoindre();
retour 0;

La sortie est:

Le code A va ici.
Le code B va ici.

Le programme commence par l'inclusion de la bibliothèque iOStream. Ensuite, il y a l'inclusion de la bibliothèque de threads, qui est un must. La ligne suivante après est une déclaration. Cette déclaration garantit que tout nom utilisé en dessous dans le programme est de l'espace de noms standard, sauf indication contraire. Ensuite, il y a la définition de la fonction de niveau supérieur, Funct ().

Après cette définition, la fonction principale (). La fonction principale () est également une définition de fonction. La première instruction de la fonction principale () instancie le thread, thr. L'argument à Thr est le nom de la fonction de niveau supérieur, Funct (). Dans cette instanciation, la fonction, funct () est appelée. Le thread efficace est la fonction de niveau supérieur. Notez que la fonction principale (), comme un thread, n'a pas de déclaration formelle pour un thread, mais la fonction, funct () a.

L'instruction suivante dans la fonction principale () est l'instruction join (). Cette déclaration doit être dans le corps de la fonction du fil d'appel. Si cette déclaration est absente, le thread principal () peut s'exécuter jusqu'à la fin sans que le thread Thr ne se compléte. En fait, si cette déclaration est absente, le compilateur G ++ ne compilera pas le programme et il émettra un message d'erreur.

Objets temporels relatifs et absolus
Durée, intervalle

La fonction sleep_for () prend un objet de durée comme argument. C'est un temps relatif. Avec l'inclusion de la bibliothèque Chrono, les objets temporels relatifs peuvent être créés comme suit:

Chrono :: heures HS (3);
Chrono :: Minutes MS (3);
Chrono :: Seconds SS (3);
Chrono :: millisecondes MSS (3);
Chrono :: microsecondes Miss (3);

Ici, il y a 3 heures avec le nom, HS; 3 minutes avec le nom, MS; 3 secondes avec le nom, SS; 3 millisecondes avec le nom, MSS; et 3 microsecondes avec le nom, Miss.

1 milliseconde = 1/1000 secondes. 1 microseconde = 1/1000000 secondes.

Temps de temps

Time_point en C ++, est le point temporel après l'époque Unix. L'Epoch Unix est le 1er janvier 1970. C'est un temps absolu. La fonction, sleep_until () utilise un objet temporel absolu comme argument. Avec l'inclusion de la bibliothèque Chrono, les objets temporels absolus, après maintenant, peuvent être créés comme suit:

chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: heures (3);
chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: minutes (3);
chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: seconds (3);
chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: millisecondes (3);
chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: microseconds (3);

Le nom de chacun de ces objets est TP.

Dormir par temps relatif
Fonction principale

Pour dormir par temps ou durée relative, la fonction sleep_for () doit être utilisée, précédée par «This_thread ::» . La durée commence à partir du moment où la fonction est exécutée. La fonction principale () est le thread principal, qui n'a besoin d'aucune déclaration. Dans le programme suivant, la fonction principale dort 1 seconde:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

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

La sortie est:

Le code A va ici.

Et après une seconde,

Le code B va ici.

est affiché. Ce programme de threads n'a pas de déclaration de discussion; Parce que le thread est la fonction principale (). Notez que la bibliothèque Chrono, ainsi que la bibliothèque de threads, ont été incluses.

La sortie est deux chaînes de la fonction principale. Entre ces chaînes, il y a le code:

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

Notez comment la fonction de sommeil a été utilisée.

Fil conventionnel

L'explication des threads conventionnels est similaire à l'explication ci-dessus, mais le code de synchronisation est dans le corps du thread réel. Dans le programme suivant, le fil dort 1 seconde:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
void funct ()
couter <<"Code A goes here." <Chrono :: Seconds SS (1);
this_thread :: sleep_for (ss);
couter <<"Code B goes here." <
int main()

thread thr (funct);
thr.rejoindre();
retour 0;

La sortie est:

Le code A va ici.

Et après une seconde,

Le code B va ici.

est affiché. Il y a deux threads ici: le thread conventionnel et la fonction principale (). Notez que la bibliothèque Chrono, ainsi que la bibliothèque de threads, ont été incluses.

La sortie est deux chaînes dans le corps de fonction du thread conventionnel. Entre ces chaînes, il y a le code:

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

Notez la relation entre ces deux déclarations.

Dormir par le temps absolu

Pour dormir à l'heure absolue, la fonction sleep_until () doit être utilisée, précédée par «this_thread ::» . Le temps commence de l'époque Unix à une époque dans le futur. Si l'argument absolu ou du temps est dans le passé, alors il serait ignoré. Ainsi, le fil devrait réellement se réveiller au moment du futur.

Fonction principale

La fonction principale () est le thread principal, qui n'a besoin d'aucune déclaration. Dans le programme suivant, la fonction principale dort jusqu'à 1 seconde après maintenant, timing à partir du 1er janvier 1970 (Unix Epoch):

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

couter <<"Code A goes here." <chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: seconds (1);
this_thread :: sleep_until (tp);
couter <<"Code B goes here." <retour 0;

La sortie est:

Le code A va ici.

Et après une seconde,

Le code B va ici.

est affiché. Il s'agit d'un programme à un thread qui n'a pas de déclaration de fil; Parce que le thread est la fonction principale (). Notez que la bibliothèque Chrono, ainsi que la bibliothèque de threads, ont été incluses.

La sortie est deux chaînes dans la fonction principale. Entre ces chaînes, il y a le code:

chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: seconds (1);
this_thread :: sleep_until (tp);

Notez comment la fonction de sommeil a été utilisée

Fil conventionnel

L'explication des threads conventionnels est similaire à l'explication ci-dessus, mais le code de synchronisation est dans le corps du thread réel. Dans le programme suivant, le fil dort jusqu'à 1 seconde après maintenant:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
void funct ()
couter << "Code A goes here." <chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: seconds (1);
this_thread :: sleep_until (tp);
couter << "Code B goes here." <
int main()

thread thr (funct);
thr.rejoindre();
retour 0;

La sortie est:

Le code A va ici.

Et après une seconde,

Le code B va ici.

est affiché. Il y a deux threads ici: le thread conventionnel et la fonction principale (). Notez que la bibliothèque Chrono, ainsi que la bibliothèque de threads, ont été incluses.

La sortie est de deux chaînes dans le corps de fonction du thread conventionnel. Entre ces chaînes, il y a le code:

chrono :: system_clock :: time_point tp = chrono :: system_clock :: maintenant () + chrono :: seconds (1);
this_thread :: sleep_until (tp);

Notez la relation entre ces deux déclarations.

Conclusion

Un fil peut être dormant pour une durée ou un sommeil et se réveiller à un moment futur depuis l'époque Unix. Pour dormir pour une durée, utilisez la fonction sleep_for (). Pour dormir et vous réveiller, utilisez la fonction sleep_until (). Chacune de ces fonctions doit être précédée par cela, "This_thread ::". Un programme C ++ simple normal est un programme fileté. Le fil ici est la fonction principale () et n'a pas besoin de déclaration de thread.