Wie fragen Sie einen pthread ab, um zu sehen, ob er noch läuft?

In meinem Destruktor möchte ich einen Thread sauber zerstören.

Mein Ziel ist es, auf die Ausführung eines Threads zu warten und DANN den Thread zu zerstören.

Das einzige, was ich über die Abfrage des Status eines pthreads gefunden habe, ist pthread_attr_setdetachstate aber das sagt dir nur, ob dein Thread ist:

• PTHREAD_CREATE_DETACHED
• PTHREAD_CREATE_JOINABLE

Beides hat nichts damit zu tun, ob der Thread noch läuft oder nicht.

Wie fragen Sie einen pthread ab, um zu sehen, ob er noch läuft?

Es hört sich so an, als hätten Sie hier zwei Fragen:

Wie kann ich warten, bis mein Thread fertig ist?

Antwort: Dies wird direkt von pthreads unterstützt – machen Sie Ihren zu stoppenden Thread JOINABLE (wenn er zum ersten Mal gestartet wird) und verwenden Sie pthread_join(), um Ihren aktuellen Thread zu blockieren, bis der zu stoppende Thread nicht mehr länger ist laufend.

Wie kann ich feststellen, ob mein Thread noch läuft?

Antwort: Sie können ein “thread_complete”-Flag hinzufügen, um den Trick auszuführen:

Szenario: Thread A möchte wissen, ob Thread B noch am Leben ist.

Wenn Thread B erstellt wird, erhält er einen Zeiger auf die “thread_complete”-Flag-Adresse. Das Flag “thread_complete” sollte auf NOT_COMPLETED initialisiert werden, bevor der Thread erstellt wird. Die Einstiegspunktfunktion von Thread B sollte sofort pthread_cleanup_push() aufrufen, um einen “Bereinigungshandler” zu pushen, der das Flag “thread_complete” auf COMPLETED setzt.

Details zu Cleanup-Handlern finden Sie hier: pthread-Bereinigungshandler

Sie sollten einen entsprechenden pthread_cleanup_pop(1)-Aufruf einschließen, um sicherzustellen, dass der Cleanup-Handler in jedem Fall aufgerufen wird (dh ob der Thread normal beendet wird ODER aufgrund eines Abbruchs usw.).

Dann kann Thread A einfach das “thread_complete”-Flag überprüfen, um zu sehen, ob Thread B bereits beendet wurde.

HINWEIS: Ihr „thread_complete“-Flag sollte als „volatile“ deklariert werden und ein atomarer Typ sein – die GNU-Compiler stellen das sig_atomic_t für diesen Zweck bereit. Dadurch können die beiden Threads konsistent auf dieselben Daten zugreifen, ohne dass Synchronisationskonstrukte (Mutexe/Semaphore) erforderlich sind.

pthread_kill(tid, 0);

Es wird kein Signal gesendet, aber es wird trotzdem eine Fehlerprüfung durchgeführt, sodass Sie dies verwenden können, um das Vorhandensein von tid zu prüfen.

VORSICHT: Diese Antwort ist falsch. Der Standard verbietet ausdrücklich die Weitergabe der ID eines Threads, dessen Lebensdauer abgelaufen ist. Diese ID kann jetzt einen anderen Thread angeben oder, schlimmer noch, auf freigegebenen Speicher verweisen, was einen Absturz verursacht.

Ich denke, alles, was Sie wirklich brauchen, ist pthread_join() aufzurufen. Dieser Aufruf wird erst zurückgegeben, wenn der Thread beendet wurde.

Wenn Sie nur abfragen möchten, ob der Thread noch läuft oder nicht (und beachten Sie, dass dies normalerweise nicht das ist, was Sie tun sollten!), könnten Sie den Thread einen flüchtigen booleschen Wert auf false setzen lassen, kurz bevor er beendet wird. Dann könnte Ihr Haupt-Thread den booleschen Wert lesen und wenn er immer noch wahr ist, wissen Sie, dass der Thread noch läuft. (Wenn es andererseits falsch ist, wissen Sie, dass der Thread zumindest fast weg ist; es kann jedoch sein, dass es immer noch Bereinigungscode ausführt, der auftritt, nachdem es den booleschen Wert auf falsch gesetzt hat, also sollten Sie auch in diesem Fall noch pthread_join vorher aufrufen versuchen, alle Ressourcen freizugeben, auf die der Thread möglicherweise Zugriff hat)

Es gibt keine vollständig portable Lösung, prüfen Sie, ob Ihre Plattform pthread_tryjoin_np oder pthread_timedjoin_np unterstützt. Sie prüfen also einfach, ob Thread beigetreten werden kann (natürlich mit PTHREAD_CREATE_JOINABLE erstellt).

Lassen Sie mich auf die “gewinnende” Antwort hinweisen, die einen großen versteckten Fehler aufweist und in einigen Zusammenhängen zu Abstürzen führen kann. Wenn Sie nicht pthread_join verwenden, wird es immer wieder auftauchen. Angenommen, Sie haben einen Prozess und eine gemeinsam genutzte Bibliothek. Rufen Sie die Bibliothek lib.so auf.

1. Wenn Sie es öffnen, beginnen Sie einen Thread darin. Angenommen, Sie möchten nicht, dass es mit ihm verbunden wird, also legen Sie fest, dass es abnehmbar ist.
2. Die Logik von Process und Shared Lib erledigt ihre Arbeit usw.
3. Sie wollen lib.so ausladen, weil Sie es nicht mehr brauchen.
4. Sie rufen den Thread zum Herunterfahren auf und sagen, dass Sie danach ein Flag aus dem Thread Ihrer lib.so lesen möchten, dass er beendet ist.
5. Sie fahren mit dlclose in einem anderen Thread fort, weil Sie sehen, dass Sie gesehen haben, dass die Flagge den Thread jetzt als “beendet” anzeigt
6. dlclose lädt den gesamten Stack- und Code-bezogenen Speicher.
7. Hoppla, aber dlclose stoppt Threads nicht. Und wissen Sie, selbst wenn Sie sich in der letzten Zeile des Cleanup-Handlers befinden, um die flüchtige atomare Flag-Variable “Thread ist beendet” zu setzen, müssen Sie immer noch von vielen Methoden auf dem Stack zurückkehren, Werte zurückgeben usw. Wenn Dem Thread von #5+#6 wurde eine große Thread-Priorität gegeben, Sie werden dlclose erhalten, bevor Sie den Thread WIRKLICH beenden konnten. Sie werden manchmal einige schöne Abstürze haben.

Lassen Sie mich darauf hinweisen, dass dies kein hypothetisches Problem ist, ich hatte das gleiche Problem bei unserem Projekt.

Ich glaube, ich habe eine Lösung gefunden, die zumindest für Linux funktioniert. Immer wenn ich einen Thread erstelle, speichere ich seine LWP (Light Weight Process ID) und weise ihm einen eindeutigen Namen zu, z. int lwp = syscall(SYS_gettid); prctl(PR_SET_NAME, (lang)”eindeutiger Name”, 0, 0, 0);

Dann, um später zu prüfen, ob der Thread existiert, öffne ich /proc/PID/Aufgabe/lwp/comm und lies es. Wenn die Datei existiert und ihr Inhalt mit dem eindeutigen Namen übereinstimmt, den ich zugewiesen habe, existiert der Thread. Beachten Sie, dass dies KEINE möglicherweise nicht mehr funktionierende/wiederverwendete TID an eine Bibliotheksfunktion weitergibt, also keine Abstürze.

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <pthread.h>
#include <sys/prctl.h>
#include <sys/file.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <syscall.h>

pthread_t subthread_tid;
int       subthread_lwp;

#define UNIQUE_NAME "unique name"

bool thread_exists (pthread_t thread_id)
{
    char path[100];
    char thread_name[16];
    FILE *fp;
    bool  thread_exists = false;

    // If the /proc/<pid>/task/<lwp>/comm file exists and it's contents match the "unique name" the
    // thread exists, and it's the original thread (TID has NOT been reused).

    sprintf(path, "/proc/%d/task/%d/comm", getpid(), subthread_lwp);

    fp = fopen(path, "r");

    if( fp != NULL ) {

        fgets(thread_name, 16, fp);
        fclose(fp);

        // Need to trim off the newline
        thread_name[strlen(thread_name)-1] = '\0';

        if( strcmp(UNIQUE_NAME, thread_name) == 0 ) {
            thread_exists = true;
        }
    }

    if( thread_exists ) {
        printf("thread exists\n");
    } else {
        printf("thread does NOT exist\n");
    }

    return thread_exists;
}


void *subthread (void *unused)
{
    subthread_lwp = syscall(SYS_gettid);
    prctl(PR_SET_NAME, (long)UNIQUE_NAME, 0, 0, 0);

    sleep(10000);

    return NULL;
}


int main (int argc, char *argv[], char *envp[])
{
    int error_number;

    pthread_create(&subthread_tid, NULL, subthread, NULL);
    printf("pthread_create()\n");
    sleep(1);
    thread_exists(subthread_tid);

    pthread_cancel(subthread_tid);
    printf("pthread_cancel()\n");
    sleep(1);
    thread_exists(subthread_tid);

    error_number = pthread_join(subthread_tid, NULL);
    if( error_number == 0 ) {
        printf("pthread_join() successful\n");
    } else {
        printf("pthread_join() failed, %d\n", error_number);
    }
    thread_exists(subthread_tid);

    exit(0);
}

#include <string.h>
#include <stdio.h>
#include <pthread.h>
#include <signal.h>
#include <unistd.h>

void* thread1 (void* arg);
void* thread2 (void* arg);

int main()
{
    pthread_t thr_id;

    pthread_create(&thr_id, NULL, thread1, NULL);

    sleep(10);
}

void* thread1 (void* arg)
{
    pthread_t thr_id = 0;

    pthread_create(&thr_id, NULL, thread2, NULL);

    sleep(5);
    int ret = 0;
    if( (ret = pthread_kill(thr_id, 0)) == 0)
    {
        printf("still running\n");
        pthread_join(thr_id, NULL);
    }
    else
    {
        printf("RIP Thread = %d\n",ret);
    }
}

void* thread2 (void* arg)
{
//  sleep(5);
    printf("I am done\n");
}