Aufruf von pthread_cond_signal ohne Sperren des Mutex

Ich habe irgendwo gelesen, dass wir den Mutex sperren sollten, bevor wir pthread_cond_signal aufrufen, und den Mutext entsperren sollten, nachdem wir ihn aufgerufen haben:

Die Routine pthread_cond_signal () wird verwendet, um einen anderen Thread zu signalisieren (oder aufzuwecken), der auf die Bedingungsvariable wartet. Es sollte aufgerufen werden, nachdem der Mutex gesperrt wurde, und muss den Mutex entsperren, damit die Routine pthread_cond_wait () abgeschlossen wird.

Meine Frage ist: Ist es nicht in Ordnung, die Methoden pthread_cond_signal oder pthread_cond_broadcast aufzurufen , ohne den Mutex zu sperren?

Wenn Sie den Mutex nicht im Codepfad sperren, der den Zustand und die Signale ändert, können Sie das Aufwecken verlieren. Betrachten Sie dieses Prozesspaar:

Prozess A:

pthread_mutex_lock(&mutex);
while (condition == FALSE)
    pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock(&mutex);

Prozess B (falsch):

condition = TRUE;
pthread_cond_signal(&cond);

Betrachten Sie dann diese mögliche Verschachtelung von Anweisungen, wobei conditionFolgendes beginnt FALSE:

Process A                             Process B

pthread_mutex_lock(&mutex);
while (condition == FALSE)

                                      condition = TRUE;
                                      pthread_cond_signal(&cond);

pthread_cond_wait(&cond, &mutex);

Das conditionist jetzt TRUE, aber Prozess A wartet nicht mehr auf die Bedingungsvariable - er hat das Wecksignal verpasst. Wenn wir Prozess B ändern, um den Mutex zu sperren:

Prozess B (richtig):

pthread_mutex_lock(&mutex);
condition = TRUE;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);

... dann kann das oben genannte nicht auftreten; Das Aufwachen wird nie fehlen.

(Beachten Sie, dass Sie können tatsächlich die bewegen pthread_cond_signal()sich nach dem pthread_mutex_unlock(), aber in weniger optimalen Planung von Threads zur Folge haben kann, und Sie haben notwendigerweise den Mutex gesperrt bereits in diesem Codepfad aufgrund Änderung der Bedingung selbst).

Nach diesem Handbuch:

Die Funktionen pthread_cond_broadcast()oder können von einem Thread aufgerufen werden, unabhängig davon, ob er derzeit den Mutex besitzt, den Threads während ihrer Wartezeit aufrufen oder der Bedingungsvariablen zugeordnet haben. Wenn jedoch ein vorhersehbares Planungsverhalten erforderlich ist, muss dieser Mutex durch den Thread, der oder aufruft, gesperrt werden .pthread_cond_signal()pthread_cond_wait()pthread_cond_timedwait()pthread_cond_broadcast()pthread_cond_signal()

Die Bedeutung der vorhersagbaren Planungsverhaltensangabe wurde von Dave Butenhof (Autor von Programming with POSIX Threads ) auf comp.programming.threads erläutert und ist hier verfügbar .

caf, in Ihrem Beispielcode ändert sich Prozess B, conditionohne zuerst den Mutex zu sperren. Wenn Prozess B den Mutex während dieser Änderung einfach gesperrt und dann den Mutex vor dem Aufruf immer noch entsperrt hat pthread_cond_signal, gibt es kein Problem - habe ich Recht damit?

Ich glaube intuitiv, dass die Position des Cafés korrekt ist: Anrufen pthread_cond_signalohne das Mutex-Schloss zu besitzen, ist eine schlechte Idee. Aber das Beispiel des Cafés ist jedoch kein Beweis für diese Position. Es ist lediglich ein Beweis für die viel schwächere (praktisch selbstverständliche) Position, dass es eine schlechte Idee ist, den durch einen Mutex geschützten gemeinsamen Status zu ändern, es sei denn, Sie haben diesen Mutex zuerst gesperrt.

Kann jemand einen Beispielcode bereitstellen, in dem ein Aufruf pthread_cond_signalgefolgt von einem pthread_mutex_unlockkorrekten Verhalten, ein Aufruf pthread_mutex_unlockgefolgt von einem pthread_cond_signalfalschen Verhalten jedoch ein korrektes Verhalten ergibt?