Verständnis von pthread_cond_wait () und pthread_cond_signal ()

Generell pthread_cond_wait() und pthread_cond_signal() genannt werden, wie unten:

//thread 1:
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
do_something()
pthread_mutex_unlock(&mutex);

//thread 2:
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);  
pthread_mutex_unlock(&mutex);

Die Schritte sind

  1. pthread_cond_wait(&cond, &mutex); heißt, es entsperrt den mutex
  2. Thread 2 sperrt den mutex und ruft pthread_cond_signal()welche entsperrt den mutex
  3. In thread 1, pthread_cond_wait() genannt wird, und sperrt den mutex wieder

Nun in thread 2, nach pthread_cond_signal() genannt wird, pthread_mutex_unlock(&mutex) laufen, mir scheint, es will zu entsperren das mutex, das ist nun gesperrt, die von thread 1. Gibt es etwas falsch in meinem Verständnis?

Außerdem, es scheint mir auch, dass pthread_cond_wait() können aufgerufen werden, indem Sie nur 1 thread für das gleiche cond-mutex-pair-Mädchen. Aber es gibt ein Sprichwort "Der pthread_cond_signal () - Funktion ist die Blockierung mindestens einer der threads, die gesperrt sind, auf die spezifizierte bedingungsvariable cond (wenn alle threads blockiert sind cond)." Also, es bedeutet pthread_cond_wait() aufgerufen werden können, von vielen threads für das gleiche cond-mutex-pair-Mädchen?

InformationsquelleAutor der Frage user1944267 | 2013-05-13

  1. 57

    pthread_cond_signal nicht entsperren des mutex (es kann nicht, wie es ohne Bezug auf den mutex, so wie konnte er wissen, was zu entsperren?) In der Tat, das signal muss nicht über eine Verbindung zu den mutex; das melde-thread nicht brauchen, um den mutex, wenn es für die meisten algorithmen basieren auf der Bedingung Variablen, es wird.

    pthread_cond_wait entsperrt den mutex kurz bevor er schläft (Sie beachten), aber dann ist es reaquires die mutex (die erfordern, warten), wenn ihm signalisiert wird, bevor es aufwacht. Also, wenn die melde-thread besitzt den mutex (der übliche Fall), der wartende thread wird nicht gehen, bis die melde-thread auch entsperrt den mutex.

    Die gemeinsame Nutzung von Zustand vars ist so etwas wie:

    thread 1:
    pthread_mutex_lock(&mutex);
    while (!condition)
        pthread_cond_wait(&cond, &mutex);
    /* do something that requires holding the mutex and condition is true */
    pthread_mutex_unlock(&mutex);

thread2:
    pthread_mutex_lock(&mutex);
    /* do something that might make condition true */
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);

    Den beiden threads haben einige gemeinsam genutzte Datenstruktur, die den mutex schützt den Zugriff auf. Der erste thread warten will, bis eine bestimmte Bedingung wahr ist dann sofort eine operation (ohne race-condition Gelegenheit für einige andere Threads zu kommen, zwischen dem Zustand prüfen und handeln und die Bedingung false wird.) Der zweite thread ist etwas zu tun, vielleicht machen die Bedingung wahr, so muss es aufwachen, jedermann, vielleicht Sie warten.

    InformationsquelleAutor der Antwort Chris Dodd

  2. 5

    Hier ist ein typisches Beispiel: thread 1 wartet auf eine Bedingung, die möglicherweise erfüllt werden, die von thread 2.

    Wir mit einem mutex und einer Bedingung.

    pthread_mutex_t mutex;
pthread_cond_t condition;

    thread 1 :

    pthread_mutex_lock(&mutex); //mutex lock
while(!condition){
    pthread_cond_wait(&condition, &mutex); //wait for the condition
}

/* do what you want */

pthread_mutex_unlock(&mutex);

    thread 2:

    pthread_mutex_lock(&mutex);

/* do something that may fulfill the condition */

pthread_mutex_unlock(&mutex);
pthread_cond_signal(&condition); //wake up thread 1

    Bearbeiten

    Wie Sie sehen können, in der pthread_cond_wait Handbuch:

    Es atomar mutex freigibt, und bewirkt, dass der aufrufende thread blockiert, die auf die bedingungsvariable cond; atomar bedeutet hier "atomar in Bezug auf den Zugang von einem anderen thread den mutex und dann die condition variable".

    InformationsquelleAutor der Antwort Ludzu

Schreibe einen Kommentar