comment obtenir l'ID de thread d'un pthread dans un programme linux c?

Dans le programme Linux C, comment imprimer l'ID de thread d'un thread créé par la bibliothèque pthread?
par exemple: on peut obtenir le pid d'un processus engetpid()

pthread_self() La fonction donnera l'identifiant du thread actuel.

pthread_t pthread_self(void);

La pthread_self()fonction renvoie le handle Pthread du thread appelant. La fonction pthread_self () ne renvoie PAS le thread intégral du thread appelant. Vous devez utiliser pthread_getthreadid_np()pour renvoyer un identificateur intégral pour le thread.

REMARQUE:

pthread_id_np_t   tid;
tid = pthread_getthreadid_np();

est nettement plus rapide que ces appels, mais offre le même comportement.

pthread_id_np_t   tid;
pthread_t         self;
self = pthread_self();
pthread_getunique_np(&self, &tid);

Quelle? La personne a demandé des informations spécifiques à Linux et l'équivalent de getpid (). Pas BSD ou Apple. La réponse est gettid () et renvoie un type intégral. Vous devrez l'appeler en utilisant syscall (), comme ceci:

#include <sys/types.h>
#include <unistd.h>
#include <sys/syscall.h>

 ....

 pid_t x = syscall(__NR_gettid);

Bien que cela puisse ne pas être portable sur les systèmes non Linux, le threadid est directement comparable et très rapide à acquérir. Il peut être imprimé (comme pour les journaux) comme un entier normal.

Comme indiqué dans d'autres réponses, pthreads ne définit pas un moyen indépendant de la plate-forme de récupérer un ID de thread intégral.

Sur les systèmes Linux, vous pouvez obtenir l'ID de thread comme suit:

#include <sys/types.h>
pid_t tid = gettid();

Sur de nombreuses plates-formes basées sur BSD, cette réponse https://stackoverflow.com/a/21206357/316487 donne un moyen non portable.

Cependant, si la raison pour laquelle vous pensez avoir besoin d'un ID de thread est de savoir si vous exécutez sur le même thread ou sur un autre thread que vous contrôlez, vous pouvez trouver un utilitaire dans cette approche

static pthread_t threadA;

// On thread A...
threadA = pthread_self();

// On thread B...
pthread_t threadB = pthread_self();
if (pthread_equal(threadA, threadB)) printf("Thread B is same as thread A.\n");
else printf("Thread B is NOT same as thread A.\n");

Si vous avez juste besoin de savoir si vous êtes sur le fil principal, il existe des moyens supplémentaires, documentés dans les réponses à cette question, comment puis-je savoir si pthread_self est le (premier) fil principal du processus? .

pid_t tid = syscall(SYS_gettid);

Linux fournit un tel appel système pour vous permettre d'obtenir l'ID d'un thread.

Vous pouvez utiliser pthread_self()

Le parent apprend à connaître l'ID de thread après l' pthread_create()exécution réussie de l ', mais lors de l'exécution du thread si nous voulons accéder à l'ID de thread, nous devons utiliser la fonction pthread_self().

Cette seule ligne vous donne pid, chaque threadid et spid.

 printf("before calling pthread_create getpid: %d getpthread_self: %lu tid:%lu\n",getpid(), pthread_self(), syscall(SYS_gettid));

pthread_getthreadid_npn'était pas sur mon Mac os x. pthread_test un type opaque. Ne vous cognez pas la tête dessus. Attribuez-le simplement void*et dites-le bien. Si vous devez printfutiliser %p.

Je pense que non seulement la question n'est pas claire, mais la plupart des gens ne sont pas non plus conscients de la différence. Examinez le dicton suivant,

Les ID de thread POSIX ne sont pas les mêmes que les ID de thread renvoyés par l' gettid()appel système spécifique à Linux . Les ID de thread POSIX sont attribués et conservés par l'implémentation de thread. L'ID de thread renvoyé par gettid()est un nombre (similaire à un ID de processus) attribué par le noyau.Bien que chaque thread POSIX ait un ID de thread de noyau unique dans l'implémentation de thread Linux NPTL, une application n'a généralement pas besoin de connaître les ID de noyau (et ne sera pas portable si cela dépend de leur connaissance).

Extrait de: The Linux Programming Interface: A Linux and UNIX System Programming Handbook, Michael Kerrisk

À mon humble avis, il n'y a qu'un seul moyen portable qui passe une structure dans laquelle définir une variable tenant des nombres de manière ascendante, par exemple 1,2,3... à par thread. En faisant cela, l'identifiant des threads peut être conservé. Néanmoins, la int pthread_equal(tid1, tid2)fonction doit être utilisée.

if (pthread_equal(tid1, tid2)) printf("Thread 2 is same as thread 1.\n");
else printf("Thread 2 is NOT same as thread 1.\n");

Il existe également un autre moyen d'obtenir l'ID de thread. Lors de la création de fils avec

int pthread_create(pthread_t * thread, const pthread_attr_t * attr, void * (*start_routine)(void *), void *arg);

appel de fonction; le premier paramètre pthread_t * threadest en fait un identifiant de thread (c'est-à-dire un long int non signé défini dans bits / pthreadtypes.h). En outre, le dernier argument void *argest l'argument qui est passé à la void * (*start_routine)fonction à threader.

Vous pouvez créer une structure pour transmettre plusieurs arguments et envoyer un pointeur vers une structure.

typedef struct thread_info {
    pthread_t thread;
    //...
} thread_info;
//...
tinfo = malloc(sizeof(thread_info) * NUMBER_OF_THREADS);
//...
pthread_create (&tinfo[i].thread, NULL, handler, (void*)&tinfo[i]);
//...
void *handler(void *targs) {
    thread_info *tinfo = targs;
    // here you get the thread id with tinfo->thread
}

Vous pouvez également écrire de cette manière et cela fait de même. Par exemple:

for(int i=0;i < total; i++)
{
    pthread_join(pth[i],NULL);
    cout << "SUM of thread id " << pth[i] << " is " << args[i].sum << endl;
}

Ce programme met en place un tableau de pthread_t et calcule la somme sur chacun. Donc, il imprime la somme de chaque thread avec l'ID de thread.

La méthode indépendante de la plate-forme (à partir de c ++ 11) est:

#include <thread>

std::this_thread::get_id();