Wie gebe ich einen Wert von pthread-Threads in C zurück?

Question 1

Ich bin neu in C und würde gerne ein bisschen mit Threads spielen. Ich möchte einen Wert aus einem Thread mit zurückgeben pthread_exit()

Mein Code ist wie folgt:

#include <pthread.h>
#include <stdio.h>

void *myThread()
{
   int ret = 42;
   pthread_exit(&ret);
}

int main()
{
   pthread_t tid;
   void *status;
 
   pthread_create(&tid, NULL, myThread, NULL);
   pthread_join(tid, &status);

   printf("%d\n",*(int*)status);   
 
   return 0;
}

Ich würde die Programmausgabe erwarten "42\n" aber es gibt eine Zufallszahl aus. Wie kann ich den zurückgegebenen Wert drucken?

Es scheint ein Problem zu sein, dass ich einen Zeiger auf eine lokale Variable zurückgebe. Was ist die beste Methode zum Zurückgeben/Speichern von Variablen mehrerer Threads? Eine globale Hash-Tabelle?

Question 2

Hier ist eine richtige Lösung. In diesem Fall wird tdata im Hauptthread zugewiesen, und es gibt Platz für den Thread, um sein Ergebnis zu platzieren.

#include <pthread.h>
#include <stdio.h>

typedef struct thread_data {
   int a;
   int b;
   int result;

} thread_data;

void *myThread(void *arg)
{
   thread_data *tdata=(thread_data *)arg;

   int a=tdata->a;
   int b=tdata->b;
   int result=a+b;

   tdata->result=result;
   pthread_exit(NULL);
}

int main()
{
   pthread_t tid;
   thread_data tdata;

   tdata.a=10;
   tdata.b=32;

   pthread_create(&tid, NULL, myThread, (void *)&tdata);
   pthread_join(tid, NULL);

   printf("%d + %d = %d\n", tdata.a, tdata.b, tdata.result);   

   return 0;
}

Question 3

Sie geben die Adresse einer lokalen Variablen zurück, die nicht mehr vorhanden ist, wenn die Thread-Funktion beendet wird. In jedem Fall, warum anrufen pthread_exit? Warum nicht einfach einen Wert aus der Thread-Funktion zurückgeben?

void *myThread()
{
   return (void *) 42;
}

und dann hauptsächlich:

printf("%d\n", (int)status);

Wenn Sie einen komplizierten Wert einer solchen Struktur zurückgeben müssen, ist es wahrscheinlich am einfachsten, ihn dynamisch über zuzuweisen malloc() und einen Zeiger zurückgeben. Natürlich ist dann der Code, der den Thread initiiert hat, für die Freigabe des Speichers verantwortlich.

Question 4

Sie haben einen Zeiger auf eine lokale Variable zurückgegeben. Das ist schlecht, auch wenn Threads nicht beteiligt sind.

Der übliche Weg, dies zu tun, wenn der Thread, der startet, derselbe Thread ist, der beitritt, wäre, einen Zeiger auf ein int an einem vom Aufrufer verwalteten Speicherort als vierten Parameter von pthread_create zu übergeben. Dies wird dann zum (einzigen) Parameter für den Einstiegspunkt des Threads. Sie können (wenn Sie möchten) den Thread-Exit-Wert verwenden, um den Erfolg anzuzeigen:

#include <pthread.h>
#include <stdio.h>

int something_worked(void) {
    /* thread operation might fail, so here's a silly example */
    void *p = malloc(10);
    free(p);
    return p ? 1 : 0;
}

void *myThread(void *result)
{
   if (something_worked()) {
       *((int*)result) = 42;
       pthread_exit(result);
   } else {
       pthread_exit(0);
   }
}

int main()
{
   pthread_t tid;
   void *status = 0;
   int result;

   pthread_create(&tid, NULL, myThread, &result);
   pthread_join(tid, &status);

   if (status != 0) {
       printf("%d\n",result);
   } else {
       printf("thread failed\n");
   }

   return 0;
}

Wenn Sie unbedingt den Thread-Exit-Wert für eine Struktur verwenden müssen, müssen Sie ihn dynamisch zuweisen (und sicherstellen, dass jeder, der dem Thread beitritt, ihn freigibt). Das ist aber nicht ideal.

Question 5

Ich denke, Sie müssen die Nummer auf dem Heap speichern. Das int ret Die Variable befand sich auf dem Stack und wurde am Ende der Ausführung der Funktion zerstört myThread.

void *myThread()
{
   int *ret = malloc(sizeof(int));
   if (ret == NULL) {
       // ...
   }
   *ret = 42;
   pthread_exit(ret);
}

Vergiss es nicht free es, wenn Sie es nicht brauchen

Eine andere Lösung besteht darin, die Zahl als Wert des Zeigers zurückzugeben, wie Neil Butterworth vorschlägt.

Question 6

#include<stdio.h>
#include<pthread.h>

void* myprint(void *x)
{
    int k = *((int *)x);
    printf("\n Thread created.. value of k [%d]\n", k);
    //k =11;
    pthread_exit((void *)k);
}

int main()
{
    pthread_t th1;
    int x =5;
    int *y;
    pthread_create(&th1, NULL, myprint, (void*)&x);
    pthread_join(th1, (void*)&y);
    printf("\n Exit value is [%d]\n", y);
}

Question 7

Sie geben einen Verweis auf zurück ret das ist eine Variable auf dem Stack.

Question 8

Frage : Was ist die beste Vorgehensweise zum Zurückgeben/Speichern von Variablen mehrerer Threads? Eine globale Hash-Tabelle?

Dies hängt ganz davon ab, was Sie zurückgeben möchten und wie Sie es verwenden würden. Wenn Sie nur den Status des Threads zurückgeben möchten (sagen Sie, ob der Thread abgeschlossen hat, was er tun wollte), verwenden Sie einfach pthread_exit oder verwenden Sie eine return-Anweisung, um den Wert von der Thread-Funktion zurückzugeben.

Wenn Sie jedoch weitere Informationen wünschen, die für die weitere Verarbeitung verwendet werden, können Sie die globale Datenstruktur verwenden. In diesem Fall müssen Sie jedoch Parallelitätsprobleme behandeln, indem Sie geeignete Synchronisierungsprimitive verwenden. Oder Sie können etwas dynamischen Speicher zuweisen (vorzugsweise für die Struktur, in der Sie die Daten speichern möchten) und ihn über pthread_exit senden, und sobald der Thread beitritt, aktualisieren Sie ihn in einer anderen globalen Struktur. Auf diese Weise aktualisiert nur der eine Hauptthread die globale Struktur, und Parallelitätsprobleme werden gelöst. Sie müssen jedoch sicherstellen, dass der gesamte von verschiedenen Threads zugewiesene Speicher freigegeben wird.