c++ - lock_guard - mutex coin

comprensión de pthread_cond_wait() y pthread_cond_signal()

Question

En términos generales, pthread_cond_wait() y pthread_cond_signal() se llaman de la siguiente manera:

//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);

Los pasos son

1. pthread_cond_wait(&cond, &mutex); Se llama, desbloquea el mutex.

2. El subproceso 2 bloquea el mutex y llama a pthread_cond_signal() , que desbloquea el mutex

3. En el hilo 1, se llama a pthread_cond_wait() y vuelve a bloquear el mutex.

Ahora, en el subproceso 2, después de llamar a pthread_cond_signal() , pthread_mutex_unlock(&mutex) se ejecutará, me parece que quiere desbloquear un mutex que ahora está bloqueado por el subproceso 1. ¿Hay algo mal en mi entendimiento?

Además, también me parece que pthread_cond_wait() puede ser llamado por solo 1 hilo para el mismo par cond-mutex. Pero hay un dicho "La función pthread_cond_signal () desbloqueará al menos uno de los subprocesos que están bloqueados en la variable de condición especificada cond (si algún subproceso está bloqueado en cond)". Entonces, ¿significa que pthread_cond_wait() puede ser llamado por muchos hilos para el mismo par cond-mutex?

Answer 1

Este es un ejemplo típico: el subproceso 1 está esperando una condición, que puede ser cumplida por el subproceso 2 .

Utilizamos un mutex y una condición.

pthread_mutex_t mutex;
pthread_cond_t condition;

hilo 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);

hilo 2:

pthread_mutex_lock(&mutex);

/* do something that may fulfill the condition */

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

Editar

Como puede ver en el manual de pthread_cond_wait :

Libera automáticamente mutex y hace que el subproceso de llamada se bloquee en la variable de condición cond; atómicamente aquí significa "atómicamente con respecto al acceso de otro hilo al mutex y luego a la variable de condición".

Answer 2

pthread_cond_signal no desbloquea el mutex (no puede, ya que no tiene ninguna referencia al mutex, así que, ¿cómo podría saber qué desbloquear?) De hecho, la señal no necesita tener ninguna conexión con el mutex; el hilo de señalización no necesita mantener el mutex, aunque para la mayoría de los algoritmos basados ​​en variables de condición lo hará.

pthread_cond_wait desbloquea el mutex justo antes de que se duerma (como se nota), pero luego vuelve a requerir el mutex (que puede requerir esperar) cuando está señalado, antes de que despierte. Entonces, si el hilo de señalización mantiene el mutex (el caso habitual), el hilo en espera no continuará hasta que el hilo de señalización también desbloquee el mutex.

El uso común de vars de condición es algo como:

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);

Los dos subprocesos tienen alguna estructura de datos compartida a la que el mutex protege el acceso. El primer hilo desea esperar hasta que se cumpla alguna condición, luego realice alguna operación de inmediato (sin ninguna posibilidad de carrera para que otro hilo entre la comprobación de condición y la acción, y haga que la condición sea falsa). El segundo hilo está haciendo algo que podría haga que la condición sea verdadera, por lo que debe despertar a cualquiera que pueda estar esperándola.