Zahn - Unix-Netzwerkprogramminerung mit Threads, Sockets und SSL

128 3 Programmieren mit POSIX-Threads
danach im Blocked-Zustand (siehe dazu Abschnitt 3.1). 2 Erst wenn ein anderer
Thread über die selbe Bedingungsvariable cond eine Veränderung der
gemeinsam genutzten Daten signalisiert, kann der wartende Thread wieder
zum Zug kommen. Allerdings muß sich der Thread vor einer Rückkehr aus
dem pthread_cond_wait()-Aufruf wieder erfolgreich um den Mutex mutex
bemühen und das System muß ihm natürlich wieder CPU-Zeit zuweisen.
#include
int pthread_cond_wait( pthread_cond_t *cond,
pthread_mutex_t *mutex );
int pthread_cond_timedwait( pthread_cond_t *cond,
pthread_mutex_t *mutex ,
const struct timespec *abstime );
Kehrt ein Thread aus pthread_cond_wait() zurück, so befindet er sich automatisch
wieder in seinem kritischen Bereich und kann mit den Arbeiten
fortfahren. Da eine Rückkehr aus der pthread_cond_wait()-Funktion keine
Aussage darüber trifft, ob die erwartete Bedingung nun erfüllt ist, muß
der Thread nun als erstes erneut prüfen, ob sich der gewünschte Zustand
der gemeinsamen Ressourcen eingestellt hat, ob also tatsächlich die Bedingung
für eine Fortsetzung seiner Arbeiten erfüllt ist. Es ist nämlich durchaus
denkbar, daß zwischen der Mitteilung über die Zustandsänderung und dem
erfolgreichen Bemühen um den schützenden Mutex bereits ein anderer Thread
seinen kritischen Bereich betreten und darin die gemeinsamen Daten erneut
verändert hat. Nachdem nun also sowohl vor als auch nach einem Aufruf
von pthread_cond_wait() geprüft werden muß, ob die erwartete Bedingung
erfüllt ist, packt man die Funktion im Normalfall in eine while-Schleife.
Die feste Bindung einer Bedingungsvariablen an einen Mutex impliziert, daß
niemals zwei Threads gleichzeitig auf die selbe Bedingungsvariable warten
und dabei zwei unterschiedliche Mutexe einsetzen dürfen. Jeder Bedingungsvariablen
muß gemäß POSIX-Standard zu jedem Zeitpunkt genau ein Mutex
zugeordnet sein. Umgekehrt dürfen einem Mutex sehr wohl mehrere Bedingungsvariablen
zugeordnet werden. Bildlich gesprochen kann ein Mutex also
mehrere Bedingungen schützen, während eine Bedingung immer vom selben
Mutex geschützt werden muß.
Soll ein Thread nicht beliebig lange auf eine Bedingungsvariable warten
müssen, so steht alternativ die Funktion pthread_cond_timedwait() bereit.
Sie ist äquivalent zu pthread_cond_wait(), wartet auf eine Bedingungsvariable
und verläßt dabei implizit den kritischen Bereich. Der Parameter abstime
2 Die Freigabe des Mutex und der Eintritt in den Blocked-Zustand werden zu einer
atomaren Operation zusammengeschweißt. Sollte also ein zweiter Thread den
Mutex sperren und eine Zustandsveränderung signalisieren, so kann der ursprüngliche
Thread bereits wieder aus seiner Wartephase geweckt werden.