Alors, sur quelle base dois-je décider si je dois utiliser pthread_self orgettid pour déterminer quel thread exécute la fonction ?
Vous devez toujours utiliser pthread_self() chaque fois que vous souhaitez identifier un thread dans votre application. gettid() peut être utilisé à certaines fins et si vous savez que c'est Linux. Par exemple, gettid() peut être utilisé pour obtenir une graine pour une graine spécifique à un thread (utilisé dans srand() ).
Les deux ne sont pas portables.
Ce n'est pas tout à fait vrai. gettid() n'est pas portable car c'est une fonction spécifique à Linux. Mais pthread_self() est portable tant que vous ne faites aucune hypothèse sur sa représentation.
Par exemple, ce qui suit n'est pas transportable.
printf("Thread ID is: %ld", (long) pthread_self());
car il n'y a aucune garantie que quoi que ce soit pthread_self() va être un nombre entier quelconque. Mais
pthread_t my_tid; //filled elsewhere
pthread_t tid = pthread_self();
if( pthread_equal(my_tid, tid) ) {
/* do stuff */
}
est entièrement portable.
Le premier n'est pas portable car il suppose cet identifiant de thread est un entier alors que ce dernier ne l'est pas.
Pourquoi y a-t-il deux fonctions différentes pour obtenir l'ID du fil ?
Ce ne sont pas deux façons différentes d'obtenir la même valeur. Un (pthread_self() est fourni par la bibliothèque de threads (pthreads) tandis que l'autre (gettid() est une fonction spécifique au système d'exploitation. Un système d'exploitation différent peut fournir une interface/un appel système différent pour obtenir un ID de thread similaire à gettid() . Vous ne pouvez donc pas compter sur gettid() dans une application portable.
pthread_self() returns the process-wide unique pthread-id.
gettid() renvoie l'ID de thread unique à l'échelle du système (spécifique à l'implémentation de pthread) (sous Linux).
the TID(thread id) returned by gettid() is unique inside a process
Oui.
(or inside a program with multiple processes,
Oui.
inside a process, different thread has different thread id.
Oui.
the TID returned by pthread_self() is unique across processes,
Non.
different thread has different TID on the same machine at the same time.
Oui dans le même processus, Non sur toute la machine.
Comme gettid() est spécifique à Linux et n'est donc pas portable, la seule façon d'identifier un pthread à grande échelle est d'utiliser son identifiant de processus parent (unique à l'échelle du système) tel qu'il est renvoyé par getpid() avec son pthread (unique à l'échelle du processus). id tel que renvoyé par pthread_self().
Il s'agit d'une étude intéressante sur la différence entre conceptuel terminologie et entités logicielles réelles (qui appartiennent à des abstractions logicielles spécifiques).
Tout d'abord, faites attention aux types de ces deux appels.
pid_t gettid(void);
pthread_t pthread_self(void);
L'un est pid_t et l'autre est pthread_t . Les deux font référence à une entité conceptuelle commune appelée thread , mais les différents types impliquent qu'il s'agit de deux software entities différents . Ce sont des représentations différentes d'un thread id , et donner un sens au sein de l'abstraction logicielle qui l'incorpore. Donc, pthread_t n'a de sens que dans l'abstraction supportée par le pthread paquet, et pid_t est logique dans l'abstraction qui incorpore ce type (c'est-à-dire les appels système Linux qui traitent de pid_t ).
Vous devez utiliser le type correct en fonction du contexte. Utilisez pthread_t dans le contexte qui requiert le type pthread_t et pid_t dans le contexte qui nécessite pid_t - indépendamment du fait qu'ils pourraient faire référence au même fil.
Chacun de ces contextes a une syntaxe prescrite pour la comparaison et l'égalité. pid_t peut être directement comparé par le == opérateur, tandis que pthread_t doit être comparé en appelant pthread_equal .
La raison de cette double représentation / abstractions logicielles est que le pthread est une bibliothèque de threads portable qui peut être implémentée sur différents systèmes d'exploitation. Différentes implémentations du pthread bibliothèque garantit que le thread id le type sera toujours pthread_t . Ces threads peuvent sous mapper à un système d'exploitation spécifique thread entity dont l'identifiant du système d'exploitation dépend du système d'exploitation (par exemple, pour Linux, il s'agit de pid_t; pour Windows c'est DWORD ).
Ainsi, bien que l'implémentation sous-jacente puisse différer d'un système d'exploitation à l'autre, le code écrit par rapport au pthread l'abstraction reste portable sur tous les systèmes d'exploitation (tant que vous vous limitez au pthread abstraction).