Wie bekomme ich die Thread-ID eines Pthreads in einem Linux C-Programm?

Wie drucke ich im Linux C-Programm die Thread-ID eines von der pthread-Bibliothek erstellten Threads?
Zum Beispiel: Wir können einen Prozess durch bekommengetpid()

pthread_self() Die Funktion gibt die Thread-ID des aktuellen Threads an.

pthread_t pthread_self(void);

Die pthread_self()Funktion gibt das Pthread-Handle des aufrufenden Threads zurück. Die Funktion pthread_self () gibt NICHT den integralen Thread des aufrufenden Threads zurück. Sie müssen verwenden pthread_getthreadid_np(), um einen integralen Bezeichner für den Thread zurückzugeben.

HINWEIS:

pthread_id_np_t   tid;
tid = pthread_getthreadid_np();

ist deutlich schneller als diese Aufrufe, bietet aber das gleiche Verhalten.

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

Was? Die Person fragte nach Linux-spezifisch und dem Äquivalent von getpid (). Nicht BSD oder Apple. Die Antwort lautet gettid () und gibt einen ganzzahligen Typ zurück. Sie müssen es mit syscall () wie folgt aufrufen:

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

 ....

 pid_t x = syscall(__NR_gettid);

Während dies möglicherweise nicht auf Nicht-Linux-Systeme portierbar ist, ist die Thread-ID direkt vergleichbar und sehr schnell zu erwerben. Es kann wie eine normale Ganzzahl gedruckt werden (z. B. für LOGs).

Wie in anderen Antworten erwähnt, definiert pthreads keine plattformunabhängige Methode zum Abrufen einer integralen Thread-ID.

Auf Linux-Systemen können Sie die Thread-ID folgendermaßen abrufen:

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

Auf vielen BSD-basierten Plattformen bietet diese Antwort https://stackoverflow.com/a/21206357/316487 einen nicht portablen Weg.

Wenn Sie jedoch der Meinung sind, dass Sie eine Thread-ID benötigen, um zu wissen, ob Sie auf demselben oder einem anderen Thread als einem anderen von Ihnen kontrollierten Thread ausgeführt werden, finden Sie möglicherweise einen Nutzen in diesem Ansatz

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

Wenn Sie nur wissen müssen, ob Sie sich im Hauptthread befinden, gibt es zusätzliche Möglichkeiten, die in Antworten auf diese Frage dokumentiert sind. Wie kann ich feststellen, ob pthread_self der Hauptthread (der erste) im Prozess ist? .

pid_t tid = syscall(SYS_gettid);

Linux bietet einen solchen Systemaufruf an, damit Sie die ID eines Threads erhalten.

Sie können verwenden pthread_self()

Das übergeordnete pthread_create()Element lernt die Thread-ID kennen, nachdem das erfolgreich ausgeführt wurde. Wenn wir jedoch während der Ausführung des Threads auf die Thread-ID zugreifen möchten, müssen wir die Funktion verwenden pthread_self().

Diese einzelne Zeile gibt Ihnen PID, jede Threadid und Spid.

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

pthread_getthreadid_npwar nicht auf meinem Mac OS X. pthread_tist ein undurchsichtiger Typ. Schlagen Sie nicht Ihren Kopf darüber. Weisen Sie void*es einfach zu und nennen Sie es gut. Wenn Sie printfverwenden %p.

Ich denke, nicht nur die Frage ist nicht klar, auch die meisten Menschen sind sich des Unterschieds nicht bewusst. Untersuche das folgende Sprichwort:

POSIX-Thread-IDs stimmen nicht mit den von Linux-spezifischen Thread-IDs zurückgegebenen Thread-IDs überein gettid() Systemaufruf zurückgegeben werden. POSIX-Thread-IDs werden von der Threading-Implementierung zugewiesen und verwaltet. Die von zurückgegebene Thread-ID gettid()ist eine Nummer (ähnlich einer Prozess-ID), die vom Kernel zugewiesen wird. Obwohl jeder POSIX-Thread eine eindeutige Kernel-Thread-ID in der Linux NPTL-Threading-Implementierung hat, muss eine Anwendung im Allgemeinen nicht über die Kernel-IDs Bescheid wissen (und ist nicht portierbar, wenn es darauf ankommt, sie zu kennen).

Auszug aus: Die Linux-Programmierschnittstelle: Ein Handbuch zur Linux- und UNIX-Systemprogrammierung, Michael Kerrisk

IMHO gibt es nur einen tragbaren Weg, der eine Struktur übergibt, in der eine Variable mit aufsteigenden Zahlen definiert wird, z 1,2,3... . B. pro Thread. Auf diese Weise kann die ID des Threads verfolgt werden. Trotzdem sollte die int pthread_equal(tid1, tid2)Funktion verwendet werden.

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

Es gibt auch eine andere Möglichkeit, die Thread-ID abzurufen. Beim Erstellen von Threads mit

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

Funktionsaufruf; Der erste Parameter pthread_t * threadist tatsächlich eine Thread-ID (dh ein vorzeichenloses langes int, das in bits / pthreadtypes.h definiert ist). Auch das letzte Argumentvoid *arg ist auch das Argument, das an die zu übergebende void * (*start_routine)Funktion übergeben wird.

Sie können eine Struktur erstellen, um mehrere Argumente zu übergeben und einen Zeiger auf eine Struktur zu senden.

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
}

Sie können auch auf diese Weise schreiben und es tut das gleiche. Zum Beispiel:

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

Dieses Programm erstellt ein Array von pthread_t und berechnet jeweils die Summe. Es wird also die Summe jedes Threads mit der Thread-ID gedruckt.

Plattformunabhängiger Weg (ab C ++ 11) ist:

#include <thread>

std::this_thread::get_id();