Pthread_cond_wait Funktion in c
Es gibt eine Art von Synchronisation, die zwischen den als Schlösser bezeichneten Threads besteht. In diesem Fall braucht Thread einen gegenseitigen Ausschluss. Es ist erforderlich, dass ein Thread gleichzeitig ausgeführt wird. Dann auch einander häufig erforderlich, wenn mehrere Fäden interagiert werden. Sie warten - warten und signalisieren. Ein Thread wartet, bis ein anderer Thread seinen Job beendet. Nach Abschluss der Ausführung dieses Threads kann der wartende Thread im Prozessor ausgeführt werden. Für eine solche Art von Threadsynchronisation benötigen wir eine andere Technik, die als beschäftigt auf einige Variablen zu warten ist. Dafür benötigen wir eine neue Synchronisation -Primitive, die als Konditionsvariablen bezeichnet wird.
Dieses Thread -Konzept ist im verschiedenen Betriebssystem verfügbar. Aber wir werden zu dem Namen, der Bedingungsvariablen, die als PThread -Bibliothek im Linux -Betriebssystem angewendet werden
Die Funktion pthread_cond_wait () ist eine Komponente des Wartens. Diese Funktion führt standardmäßig die Entsperraktion aus.
Programmierbeispiel-1:
In diesem Programm -Beispiel werden wir sehen, wie diese Funktion ausgeführt wird:
#enthalten#enthalten
#enthalten
#enthalten
#enthalten
pthread_mutex_t m = pthread_mutex_initializer; // Deklarieren Sie die Bedingungsvariable.
pthread_cond_t c = pthread_cond_initializer;
int fertig = 0;
void Thr_exit ()
pthread_mutex_lock (& m);
fertig = 1;
pthread_cond_signal (& c);
pthread_mutex_unlock (& m);
void *mild (void *arg) // Child Process Execututs.
printf ("child \ n");
Thr_exit ();
null zurückkehren;
void thr_join ()
pthread_mutex_lock (& m);
while (done == 0)
pthread_cond_wait (& c, & m); // Ruf die Funktion in der Funktion Thr_join () auf.
pthread_mutex_unlock (& m);
int main (int argc, char* argv [])
printf ("Eltern: Begin \ n");
pthread_tp;
pthread_create (& p, null, Kind, null); // den Thread initialisieren.
Thr_join ();
printf ("Eltern: Ende \ n");
Rückkehr 0;
Ausgang:
Erläuterung
In diesem Programmierbeispiel gibt es zwei Prozesse, die als übergeordnete Thread und ein untergeordneter Thread bezeichnet werden. Hier möchte Eltern auf das Kind warten. Nach Abschluss der Ausführung des Kinderprozesses startet Eltern seine Ausführung.
Für die Innenseite der Main () erstellen wir den Eltern- und Kinderfaden. Child -Thread führt die Funktion namens Child () aus. Dann ruft der übergeordnete Thread den Funktionsverbinden auf. Dieser Join () prüft im Grunde, dass das Kind fertig ist. Andernfalls wird es warten, indem die Funktion pThread_cond_wait () verwendet wird. Wenn das Kind läuft, ruft es die Exit () auf (). Wenn die Ausführung des Kindes erfolgt, wird der Wert der abgeschlossenen Variablen 1 betragen. Dann ruft es das Signal in der Bedingungsvariablen auf. Danach beginnt die Ausführung des übergeordneten Threads.
Warten Sie und Signalsyntax:
void Thr_exit ()fertig = 1;
pthread_cond_signal (& c);
void thr_join ()
if (done == 0)
pthread_cond_wait (& c);
Was passiert, wenn wir kein Schloss bekommen? Es wird eine Rennbedingung auftreten - verpasste Aufwachen.
- Der übergeordnete Prozess hat nichts für die Ausführung und das Eingehen in Leerlaufzustand, für diesen Fall kann eine Unterbrechung auftreten.
- Wenn das Kind seinen Code ausführt und seine Ausführung erreicht hat, signalisiert es, aber noch niemand schläft.
- Der Elternteil startete nun seine Ausführung von dem Ort, an dem es fertig war, und muss auf einen bestimmten Zeitraum gewartet werden.
- Denn diese Wartefunktion muss sich im Kopf behalten, dass der Thread für einen längeren Zeitraum nicht suspendiert wird. Es muss sein Schloss geöffnet werden.
Programmierbeispiel 2:
In diesem Programm -Beispiel werden wir eine weitere Verwendung von pThread_cond_wait Fuktion sehen.
#enthalten#enthalten
#enthalten
#enthalten
#enthalten
pthread_mutex_tmutexFuel;
pthread_cond_tcondfuel; // Erstellen Sie die Zustandsvariable.
int Kraftstoff = 0;
void* tanking (void* arg)
für (int i = 0; i < 5; i++)
pthread_mutex_lock (& mutexFuel);
Kraftstoff += 15;
printf ("Got Kraftstoff ... %d \ n", Kraftstoff);
pthread_mutex_unlock (& mutexFuel);
pthread_cond_signal (& condFuel);
Schlaf (1);
void* vehium (void* arg)
pthread_mutex_lock (& mutexFuel);
während (Kraftstoff < 40)
printf ("Null Kraftstoff. Warten ... \ n ");
pthread_cond_wait (& condFuel, & mutexFuel);
// Gleichwertig:
// pthread_mutex_unlock (& mutexfuel);
// Warte auf Signal auf CondFuel
// pthread_mutex_lock (& mutexfuel);
Kraftstoff -= 40;
printf ("Treibstoff jetzt gelassen: %d \ n", Kraftstoff);
pthread_mutex_unlock (& mutexFuel);
int main (int argc, char* argv [])
pthread_ta [2];
pthread_mutex_init (& mutexfuel, null);
pthread_cond_init (& condFuel, null);
für (int i = 0; i < 2 ; i++ )
if (i == 1)
if (pthread_create (& a [i], null & tanking, null) != 0)
perror ("nicht erstellt Thread");
anders
if (pthread_create (& a [i], null & fahrzeug, null) != 0)
perror ("nicht erstellt Thread");
für (int i = 0; i < 2 ; i++ )
if (pthread_join (a [i], null) != 0)
Perror ("nicht mit Thread zusammengefügt");
pthread_mutex_destroy (& mutexFuel);
pthread_cond_destroy (& condFuel); // die Fäden zerstören.
Rückkehr 0;
Ausgang:
Erläuterung
Hier sehen wir die Anwendung der Funktion pThread_cond_wait (). Es ist so, als ob jemand den Kraftstoff sein Auto füllen möchte. Er muss warten, bis sein Auto mit Treibstoff gefüllt wird. Dafür erstellen wir zwei Themen. Eine zum Füllen des Kraftstoffs im Auto und für das Auto. Wir werden zwei Funktionen definieren. Eine ist die Funktion () fördert (), die feststellt. Der Typ, der den Kraftstoff in seinem Auto füllen möchte, muss warten, bis der Treibstoff ausgefüllt ist.
In der Funktion main () erstellen wir zwei Fäden für die Funktion des Fueling () und für die Fahrzeug () -Funktion. Jetzt erstellen wir eine Zustandsvariable, um auf den Zustand zu warten. Dafür werden wir die Ausgabe sehen. Wenn Funktionen ihre Ausführung vervollständigen, werden wir diese Themen zerstören.
Abschluss
Die Funktion pThread_cond_wait () benachrichtigt, wenn wir mit Hilfe mehrerer Threads ein Programm durchgeführt haben. Diese Funktion macht einige Zustandsvariablen, um diese Threads zu verarbeiten. Tatsächlich hängt die Eigenschaften dieser Funktion vollständig vom Prinzip von ab Warten Sie und signalisieren Theorie.