Pthread_join Funktion in C -Sprache mit einzelnen und mehreren Thread -Beispielen
Um ein erfolgreiches Programm mit dieser Programmiermethode zu erstellen, müssen Sie einige besondere Überlegungen vornehmen. Wenn beispielsweise die Ausführungszeiten eines Threads länger sind als die der main () -Funktion und vollständig ausgeführt wird, endet das Programm und so alle zugehörigen Threads, unabhängig davon, ob sie ihre Aufgabe abgeschlossen haben oder nicht.
Dies kann kritische Probleme verursachen, da ein Thread, der unerwartet endet.
In diesem Linux -Hinweis -Artikel erfahren Sie, wie Sie die Funktion pThread_join () verwenden, um sicherzustellen.
Syntax der Funktion pThread_join () in der C -Sprache
int pthread_join (pthread_t thread, void ** retval);
Beschreibung der Funktion pThread_join () in der C -Sprache
Die Funktion pThread_join () wartet auf den Prozess, aus dem er aufgerufen wird, bis ein Thread seine Aufgabe beendet hat. Diese Funktion setzt die Funktion aus, aus der sie aufgerufen wird, bis der Subprozess, der durch ihre Kennung im Thread-Eingangsargument angegeben ist.
Sobald der Thread seine Aufgabe beendet hat, setzt das Programm die Ausführung aus der nächsten Zeile des Codes fort, die das pthread_join () aufruft, um aufzurufen.
Wenn der Unterprozess endet.
Als nächstes sehen wir die Eingabeargumente an die phread_join () sowie eine Beschreibung der Funktion, die jedes dieser Argumente erfüllt:
Gewinde: Dieses Eingabargument ist ein Datenwert des Typs pthread_t und die Kennung des Subprozesses, den die Funktion pThread_join () erwarten sollte.
Der Wert der Kennung wird vom System erzeugt und als Ergebnis der Funktion pThread_create () in seinem Ausgangsargument -Thread erhalten, wenn der Thread erstellt wird.
Retval: Dieses Eingabargument ist ein Zeiger auf (void *), bei dem die Funktion pThread_join () den Exit -Status des Threads speichert.
Wenn pThread_join () erfolgreich zurückgibt, gibt es 0 als Ergebnis zurück. Wenn ein Fehler auftritt, gibt diese Funktion eine Ganzzahl mit einem Wert zurück, der den aufgetretenen Fehler darstellt. Später sehen Sie einen speziellen Abschnitt, der alle Fehler beschreibt, die diese Funktion generieren kann und wie sie identifiziert werden können.
Die Funktion pThread_join () ist im pThread definiert.H Kopfball. Um es zu verwenden, müssen die folgenden Header in die “enthalten sein.c ”Datei, wie in Folgendes gezeigt:
#enthalten
#enthalten
Hinweis: Es ist wichtig, dass Sie diese Funktion nur bei Bedarf verwenden, da Sie die Ausführungszeit eines Programms verlängern können.
Kompilierungsfehler in Programmen mit Threads
Wenn Sie die GCC -Programme kompilieren, die Threads verwenden.
Die häufigste Fehlermeldung, die vom Compiler ausgegeben wird.
Diese Fehler führen häufig dazu, eine wertvolle Zeit zu verschwenden, um die von uns in den Code eingefügten Header, ihre Integrität und die mit dem Compiler verbundenen Verzeichnisse zu überprüfen, da alles anzeigt, dass das Problem da ist.
Obwohl die Funktionen, die den Fehler verursachen.H ”Header und im Code enthalten. Der Compiler erkennt diese Funktionen nicht, es sei denn.
In der folgenden Abbildung sehen Sie die richtige Möglichkeit, die PThread -Bibliothek (in grün hervorgehoben) während der Zusammenstellung von Programmen mit Threads aus der Befehlskonsole aufzurufen:
~ $ GCC -PTHEAD PATH/Dateiname.c -o out_name
Wie wir in der folgenden Abbildung sehen können, verschwindet der Fehler, wenn die PThread -Bibliothek während der Zusammenstellung aufgerufen wird.
So verwenden Sie die Funktion pThread_join (), um auf einen Thread zu warten, um die Ausführung in der C -Sprache abzuschließen
In diesem Beispiel erstellen wir einen Thread, der eine längere Ausführungszeit hat als die main () -Funktion. Nach dem Erstellen des Thread.
Zu diesem Zweck erstellen wir die Funktion thread_f (), die den Thread ausführt. Diese Funktion ist eine „für“ -Schloop mit 5 Zyklen einer Sekunde Dauer, von denen jedes die “druckt“Sekunden bis Ende des Threads:Meldung, gefolgt von der Anzahl der verbleibenden Sekunden in der Befehlskonsole.
Aus der Funktion main () erstellen wir den Thread_1 mit der Funktion pThread_create ()). Dann nennen wir die Funktion pThread_join (), um darauf zu warten, bis der Unterprozess die Ausführung abgeschlossen hat, bevor wir das Programm verlassen.
Der Funktionsaufruf von pthread_join () wird mit dem Thread_1 -Kennung als erstes Eingabebericht und das RetVal als Null im zweiten Argument verwendet. Wir sehen den folgenden vollständigen Code für dieses Beispiel:
#enthalten
#enthalten
#enthalten
#enthalten
void* thread_f (void* n);
int main ()
pthread_t thread_1;
pthread_create (& thread_1, null, thread_f, null);
pthread_join (Thread_1, null);
Rückkehr 0;
void* thread_f (void* n)
für (int a = 5; a!= 0; A--)
printf ("Sekunden bis Ende von Thread: %i \ n", a);
Schlaf (1);
printf ("Ende des Threads \ n");
pThread_exit (n);
Das folgende Bild zeigt die Kompilierung und Ausführung dieses Code:
Wie wir in der Abbildung sah. Lassen Sie uns sehen, was passiert, wenn wir die Funktion pThread_join () entfernen. Kompilieren und führen Sie den folgenden Code aus:
Wie wir in der Abbildung sehen können.
So verwenden Sie die Funktion pThread_join (), um auf einen mehrfachen Thread zu warten, um die Ausführung in der C -Sprache abzuschließen
In diesem Beispiel zeigen wir Ihnen, wie Sie die Funktion pThread_join () verwenden, um auf mehrere gleichzeitige Threads zu warten.
Dazu verwenden wir den Code aus dem vorherigen Beispiel und fügen einen zweiten Thread hinzu, der Thread_2 ist, und eine zweite Routine, die Thread_F_2 () ist, die parallel mit Thread_1 ausgeführt wird. Die Ausführungszeit dieser Routine ist doppelt so lang wie die von Thread_f_1 (), der 10 Sekunden dauert.
Die Methode, die wir verwenden, besteht darin, die beiden Threads nacheinander mit der Funktion pThread_create () zu erstellen. Dann rufen wir zuerst die Funktion pThread_join () mit dem kürzesten laufenden Thread auf, gefolgt von einem neuen Aufruf zu dieser Funktion mit dem längsten laufenden Thread. Das Folgende ist der vollständige Code für dieses Beispiel:
#enthalten
#enthalten
#enthalten
#enthalten
void* thread_f_1 (void* n);
void* thread_f_2 (void* n);
int main ()
pthread_t thread_1;
pthread_t thread_2;
pthread_create (& thread_1, null, thread_f_1, null);
pthread_create (& thread_2, null, thread_f_2, null);
pthread_join (Thread_1, null);
pthread_join (Thread_2, null);
Rückkehr 0;
void* thread_f_1 (void* n)
für (int a = 5; a!= 0; A--)
printf ("Sekunden bis Ende von Thread 1: %i \ n", a);
Schlaf (1);
printf ("Ende von Thread 1 \ n");
pThread_exit (n);
void* thread_f_2 (void* n)
für (int a = 10; a!= 0; A--)
printf ("Sekunden bis Ende von Thread 2: %i \ n", a);
Schlaf (1);
printf ("Ende von Thread 2 \ n");
pThread_exit (n);
Wie wir im folgenden Bild sehen, haben beide Threads ihre Ausführung abgeschlossen:
Fehler, die die Funktion pThread_join () zurückgeben kann: Was sind sie und wie können sie erkannt werden??
Wenn ein Fehler auftritt, gibt die Funktion pThread_join () eine der folgenden vordefinierten Codes zurück:
Esrch: Die angegebene Kennung ist keinem Thread zugeordnet.
Einval: Der Thread ist nicht Joinable oder ein anderer Thread wartet bereits darauf, diesem beizutreten.
Edeadlk: Ein Absturz wird erkannt.
Diese Fehler sind im „Errno vordefiniert.H ”-Header und werden als Ergebnis in der Ausgabegleger der Funktion pThread_join () zurückgegeben, nicht im globalen Variablen -Errno.
Das Folgende ist der Code aus dem vorherigen Beispiel, in dem wir eine „if“ -Simit hinzufügen, um festzustellen, ob ein Fehler aufgetreten ist. In diesem Fall gibt das Programm in eine Switch -Bedingung ein, die den Fehler identifiziert und eine Nachricht in der Befehlskonsole mit der spezifischen Beschreibung dieses Fehlers anzeigt.
Wir schließen auch die „Errno ein.H ”-Header und deklarieren Sie die Fehlervariable, die die Bedingungen„ If “und„ Switch “sind.
Um den Fehler zu generieren, beziehen wir uns auf den Thread_2 im Thread -Eingangsargument der Funktion pThread_join (), die nicht erstellt wird.
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
void* thread_f (void* n);
int main ()
im Terror;
pthread_t thread_1;
pthread_t thread_2;
pthread_create (& thread_1, null, thread_f, null);
ERROR = PTHREAD_JOIN (Thread_2, NULL);
if (Fehler!= 0)
Switch (Fehler)
Fall ESRCH:
printf ("Die Kennung ist keinem Thread \ n");
brechen;
Fall Einval:
printf ("Thread nicht verbinden oder ein anderer Thread wartet bereits \ n");
brechen;
Case Edeadlk:
printf ("Ein Absturz wurde festgestellt.\N");
brechen;
Rückkehr 0;
void* thread_f (void* n)
für (int a = 5; a!= 0; A--)
printf ("Sekunden bis Ende von Thread: %i \ n", a);
Schlaf (1);
printf ("Ende des Threads \ n");
pThread_exit (n);
Das folgende Bild zeigt die Kompilierung und Ausführung dieses Code. Sehen Sie, wie das Programm in die Anweisung „if“ und die ESRCH-Instanz der Switch-Anweisung eingeht, die angibt, dass der Thread_2-Kennung auf einen nicht existierenden Thread zeigt. Sie können auch sehen, dass die Ausführung von Thread_1 unvollständig ist.
Abschluss
In diesem Linux-Hinweis-Artikel haben wir Ihnen gezeigt, wie Sie die Funktion pThread_join () aus der Thread-Bibliothek implementieren, um eine vollständige Ausführung eines Unterprozesses zu gewährleisten.
Wir haben die Syntax dieser Funktion erläutert und jedes seiner Eingabeberechtigung beschrieben und wie sie die Daten erhalten, die darin übergeben werden müssen. Anschließend haben wir die Funktion in einem praktischen Beispiel mit Code -Snippets und Bildern implementiert, um zu zeigen, wie Sie die Funktion pThread_join () verwenden können, um eine vollständige und zuverlässige Ausführung eines Threads zu gewährleisten.
Wir haben Ihnen auch gezeigt, wie Sie die Threadbibliothek für fehlerfreie Kompilierung korrekt verknüpfen können. In einem speziellen Abschnitt haben wir Ihnen gezeigt.