Comment obtenir l'identifiant de fil en C++?

Avant de savoir comment obtenir l'ID de fil d'un fil, vous devez d'abord connaître les deux formes de l'ID de fil en C++. Cela correspond à savoir quel ID est obtenu lorsque le thread n'est pas en cours d'exécution et quel ID est obtenu lorsque le thread est en cours d'exécution. Exécuter signifie exécuter. Un identifiant (pour l'identifiant) est ce qui identifie quelque chose. En C ++, le nom de l'ID de fil est ID, en minuscules.

Pour le thread en C ++, un ID est un objet avec des membres de données et des fonctions membres. Cet objet ID a un code texte, ce que les gens considèrent normalement comme l'ID. L'objet ID utilise le << operator to send the text code to the cout object (terminal). The id object and its text code are different from when the thread is not running to when it is running.

Le thread est une classe dans laquelle l'objet ID est un membre de données. L'objet ID peut être obtenu avec la syntaxe suivante:

thread :: get_id ()

La syntaxe «thread :: get_id ()» peut être utilisée lorsque le thread n'est pas en cours d'exécution et aussi lorsque le thread est en cours d'exécution, et il donnera des objets différents et des codes de texte correspondants pour les deux situations différentes.

Un moyen d'obtenir l'ID de thread dans le corps du thread pendant qu'il s'exécute est d'utiliser la syntaxe:

this_thread :: get_id ()

Tous les threads qui s'exécutent ont des objets d'identification différents et des codes texte correspondants. Tous les threads qui ne fonctionnent pas ont le même code texte correspondant pour le même programme. Bien qu'ils aient le même code texte, tous les threads qui ne fonctionnent pas ont des objets d'identification différents parce que les objets sont des références et non des pointeurs.

Un thread qui s'exécute est appelé thread-of-exécution.

Pour compiler un programme de threads, avec le compilateur G ++, utilisez une commande similaire à:

g ++ -std = c ++ 2a temp.cpp -lpthread -o temp

Cet article explique différentes façons d'obtenir des identifiants de différents threads en C ++, en commençant par un résumé de ce qu'est un fil.

Contenu de l'article

• Résumé du fil
• Obtention de l'ID de thread
• Utilisation de this_thread :: get_id ()
• Conclusion

Résumé du fil

Un thread est une enceinte d'une fonction de niveau supérieur. Un thread est instancié de la classe de threads. Le nom de la fonction de niveau supérieur est un argument à la fonction du constructeur de l'objet thread. La fonction principale () en C ++ est également une fonction de niveau supérieur. Ainsi, la fonction principale () se comporte comme le fil principal. Le programme suivant montre deux threads dont la fonction principale () est une:

#inclure
#inclure
Utilisation de Namespace Std;
Thread Thr;
void fun ()
couter <<"This is line A." <couter <<"This is line B." <
int main()

thr = thread (fun);
thr.rejoindre();
/ * instructions * /
retour 0;

La sortie est:

C'est la ligne a.
C'est la ligne B.

Les fonctions de niveau supérieur sont amusantes () et main (). main () est comme le fil principal. Le nom de la fonction de niveau supérieur, Fun () est l'argument du constructeur du thread, thr, dans la fonction principale.

Le programme commence par l'inclusion de la bibliothèque iOStream. Ceci est suivi par l'inclusion de la bibliothèque de threads. L'énoncé après cela garantit que tout nom utilisé dans le programme est de l'espace de noms standard, sauf indication contraire.

Ensuite, le thread thr est déclaré sans appel de fonction. La fonction de niveau supérieur, Fun () est ensuite définie. Par la suite est la définition de la fonction principale (). La première instruction dans main (), attribue la fonction, fun () au thread, thr, ainsi que l'appel de la fonction.

La deuxième déclaration de Main () est la déclaration de jointure. Si cette déclaration est absente, le thread principal peut fonctionner jusqu'à l'achèvement sans le thread, Thr fonctionnant à sa propre fin. Avec cette instruction, au point où l'instruction est tapée, le thread principal (fonction) s'arrête (blocs) et permet au thread joint (Thr) de s'exécuter à son achèvement; Avant que le fil principal ne continue de terminer. Une tentative de compilation du programme sans l'instruction JOIN devrait se retrouver avec un message d'erreur et aucune compilation.

Lorsque le fil est déclaré avec l'instruction,

Thread Thr;

Ce n'est pas un fil en cours d'exécution; Aucune fonction n'est en cours d'exécution. Cependant, lorsque le thread, Thr reçoit un nom de fonction comme argument, comme dans,

thr = thread (fun);

Il devient un fil en cours d'exécution. Cette déclaration est également un appel de fonction, pour la fonction, fun ().

Après l'instruction JOIN dans la fonction principale, le thread, Thr a terminé son exécution, et ce n'est plus un thread en cours d'exécution. À cet état, son identifiant est différent de son cours.

Obtention de l'ID de thread

Le programme suivant montre le moyen de base d'obtenir l'ID de thread lorsque le thread ne s'exécute pas et aussi lorsqu'il s'exécute:

#inclure
#inclure
Utilisation de Namespace Std;
Thread Thr;
void fun ()
couter <<"This is line A." <thread :: id idr = thr.get_id ();
couter <couter <<"This is line B." <
int main()

thread :: id idd = thr.get_id ();
couter <thr = thread (fun);
thr.rejoindre();
// cout </ * instructions * /
retour 0;

La sortie de l'ordinateur de l'auteur est:

Thread :: ID d'un fil non exécutif
C'est la ligne a.
140362842543872
C'est la ligne B.

thr est une variable globale. Il est utilisé dans le corps de fonction du fil thr, dans l'instruction:

thread :: id idr = thr.get_id ();

La variable tenant l'objet de thread obtenu est iRr. Bien que l'ID soit un objet instancié, il est également membre de la classe de threads. Ainsi, la déclaration de l'IDR doit être:

thread :: id idr

avec le point-virgule. La déclaration suivante après celle-ci est:

couter <

L'opérateur, <

thread :: id idd = thr.get_id ();

Dans la fonction principale (). C'est la même chose que celle de la fonction d'exécution de thread, à l'exception de la variable de réception, idd. Cette instruction est exécutée avant le thread, Thr se voit attribuer une fonction. L'ID de texte (code) pour ce thread qui ne s'exécute pas est:

Thread :: ID d'un fil non exécutif

Pendant l'exécution de la fonction principale (), le thread Thr a terminé sa propre exécution après l'instruction JOIN. Et donc, "Thr.get_id () ”devrait pouvoir renvoyer l'ID du fil lorsqu'il ne s'exécute pas. À partir de maintenant, le programme C ++ compilé avec G ++ a du mal à obtenir l'ID du fil qui s'est complété. C'est pourquoi l'instruction ID après l'instruction JOIN dans le code ci-dessus est commentée.

Utilisation de this_thread :: get_id ()

"This_thread ::" est codé dans le thread de l'exécution (fonction). Il représente le fil qui s'exécute actuellement. Il peut être suivi d'une fonction pour le thread, comme get_id (), pour avoir

this_thread :: get_id ()

Pour obtenir l'ID du thread en cours d'exécution du thread, qui est différent de l'ID lorsque le thread ne s'exécute pas.

"This_thread ::" est utilisé dans le corps de la fonction d'un thread. Le programme suivant illustre cela pour le fil, THR:

#inclure
#inclure
Utilisation de Namespace Std;
Thread Thr;
void fun ()
couter <<"This is line A." <thread :: id idr = this_thread :: get_id ();
couter <couter <<"This is line B." <
int main()

thread :: id idd = thr.get_id ();
couter <thr = thread (fun);
thr.rejoindre();
retour 0;

La sortie de l'ordinateur de l'auteur est:

Thread :: ID d'un fil non exécutif
C'est la ligne a.
140199206078208
C'est la ligne B.

Notez que le nom de thread, Thr, n'a pas été utilisé dans le corps de la fonction de thread, dans ce cas.

Conclusion

Il existe deux formes de l'ID de fil en C++. L'ID lorsque le thread s'exécute est différent de l'ID lorsque le thread ne s'exécute pas. Un identifiant (pour l'identifiant) est ce qui identifie quelque chose. En C ++, le nom de l'ID de fil est ID, en minuscules. Ceci est un membre de données dans la classe de threads. Ce n'est pas un objet fondamental. Il est instancié de sa propre classe, de l'espace de noms, thread :: id. Bien que l'ID soit un objet, il a un formulaire de texte correspondant. Le formulaire de texte peut être inséré dans l'objet COUT (terminal) avec l'opérateur d'insertion C ++, <<.

Chaque thread a deux ID différents: un lorsque le thread est en cours d'exécution; et l'autre lorsque le fil ne fonctionne pas. Lorsque le thread n'est pas en cours d'exécution, le formulaire de texte pour l'ID est différent du formulaire de texte lorsque le thread est en cours d'exécution pour le même thread.

La spécification C ++ a différentes façons d'obtenir l'ID de thread. Cependant, pour l'instant, avec le compilateur G ++, les seules façons d'obtenir l'ID proviennent des expressions: «ThreadObject.get_id () "et" this_thread :: get_id () ". "This_thread :: get_id ()" est utilisé dans le corps de fonction du thread exécuteur, où "this_thread ::" fait référence au fil en cours d'exécution. Un thread en cours d'exécution est appelé thread d'exécution.