come ottenere l'ID thread di un pthread nel programma linux c?

Nel programma linux c, come stampare l'ID del thread di un thread creato dalla libreria pthread?
ad esempio: possiamo ottenere il pid di un processo dagetpid()

pthread_self() la funzione fornirà l'id del thread del thread corrente.

pthread_t pthread_self(void);

La pthread_self()funzione restituisce l'handle Pthread del thread chiamante. La funzione pthread_self () NON restituisce il thread integrale del thread chiamante. È necessario utilizzare pthread_getthreadid_np()per restituire un identificatore integrale per il thread.

NOTA:

pthread_id_np_t   tid;
tid = pthread_getthreadid_np();

è significativamente più veloce di queste chiamate, ma fornisce lo stesso comportamento.

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

Che cosa? La persona ha chiesto specifiche per Linux e l'equivalente di getpid (). Non BSD o Apple. La risposta è gettid () e restituisce un tipo integrale. Dovrai chiamarlo usando syscall (), in questo modo:

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

 ....

 pid_t x = syscall(__NR_gettid);

Anche se questo potrebbe non essere portabile su sistemi non Linux, il threadid è direttamente confrontabile e molto veloce da acquisire. Può essere stampato (come per i LOG) come un normale intero.

Come notato in altre risposte, pthreads non definisce un modo indipendente dalla piattaforma per recuperare un ID thread integrale.

Su sistemi Linux, puoi ottenere l'ID del thread in questo modo:

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

Su molte piattaforme basate su BSD, questa risposta https://stackoverflow.com/a/21206357/316487 offre un modo non portatile.

Tuttavia, se il motivo per cui ritieni di aver bisogno di un ID thread è sapere se stai eseguendo lo stesso thread o un thread diverso su un altro thread che controlli, potresti trovare qualche utilità in questo approccio

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");

Se hai solo bisogno di sapere se sei nel thread principale, ci sono altri modi, documentati nelle risposte a questa domanda, come posso sapere se pthread_self è il thread principale (primo) nel processo? .

pid_t tid = syscall(SYS_gettid);

Linux fornisce tale chiamata di sistema per consentire di ottenere l'ID di un thread.

Puoi usare pthread_self()

Il genitore conosce l'id del thread dopo che pthread_create()è stato eseguito con successo, ma durante l'esecuzione del thread se vogliamo accedere all'id del thread dobbiamo usare la funzione pthread_self().

Questa singola riga ti dà pid, ogni threadid e spid.

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

pthread_getthreadid_npnon era sul mio Mac os x. pthread_tè un tipo opaco. Non sbatterci la testa sopra. Assegnalo void*e chiamalo buono. Se hai bisogno di printfusare %p.

Penso che non solo la domanda non sia chiara, ma anche la maggior parte delle persone non è consapevole della differenza. Esamina il seguente detto,

Gli ID thread POSIX non sono gli stessi degli ID thread restituiti dalla gettid()chiamata di sistema specifica di Linux . Gli ID thread POSIX vengono assegnati e gestiti dall'implementazione del threading. L'ID thread restituito da gettid()è un numero (simile a un ID processo) assegnato dal kernel. Sebbene ogni thread POSIX abbia un ID thread del kernel univoco nell'implementazione del threading NPTL di Linux, un'applicazione generalmente non ha bisogno di conoscere gli ID del kernel (e non sarà portabile se dipende dalla loro conoscenza).

Tratto da: The Linux Programming Interface: A Linux and UNIX System Programming Handbook, Michael Kerrisk

IMHO, c'è solo un modo portabile che passa una struttura in cui definire una variabile contenente numeri in modo crescente, ad esempio 1,2,3... per thread. In questo modo, l'id dei thread può essere tenuto traccia. Tuttavia, la int pthread_equal(tid1, tid2)funzione dovrebbe essere utilizzata.

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");

C'è anche un altro modo per ottenere l'ID del thread. Durante la creazione di thread con

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

chiamata di funzione; il primo parametro pthread_t * threadè in realtà un ID thread (che è un int lungo senza segno definito in bits / pthreadtypes.h). Inoltre, l'ultimo argomento void *argè l'argomento a cui viene passato void * (*start_routine) funzione da sottoporre a thread.

È possibile creare una struttura per passare più argomenti e inviare un puntatore a una struttura.

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
}

Puoi anche scrivere in questo modo e fa lo stesso. Ad esempio:

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

Questo programma imposta un array di pthread_t e calcola la somma su ciascuno. Quindi stampa la somma di ogni thread con ID thread.

Il modo indipendente dalla piattaforma (a partire da c ++ 11) è:

#include <thread>

std::this_thread::get_id();