Estoy tratando de entender mejor cómo usar pthread_cond_wait() y cómo funciona. Solo estoy buscando un poco de aclaración a una respuesta que vi en este sitio.
La respuesta es la última respuesta en esta página.
comprensión de pthread_cond_wait() y pthread_cond_signal()
Me pregunto cómo se vería esto con tres hilos. Imagine Thread 1 quiere decirle a Thread 2 y Thread 3 que se despierten
Por ejemplo
pthread_mutex_t mutex; pthread_cond_t condition;Hilo 1 :
pthread_mutex_lock(&mutex); /*Initialize things*/ pthread_mutex_unlock(&mutex); pthread_cond_signal(&condition); //wake up thread 2 & 3 /*Do other things*/Hilo 2 :
pthread_mutex_lock(&mutex); //mutex lock while(!condition){ pthread_cond_wait(&condition, &mutex); //wait for the condition } pthread_mutex_unlock(&mutex); /*Do work*/Hilo 3 :
pthread_mutex_lock(&mutex); //mutex lock while(!condition){ pthread_cond_wait(&condition, &mutex); //wait for the condition } pthread_mutex_unlock(&mutex); /*Do work*/Me pregunto si tal configuración es válida. Digamos que los subprocesos 2 y 3 se basaron en algunas opciones de inicialización que el subproceso 1 necesita procesar.
Primero: si desea que el subproceso n #1 active los subprocesos n #2 y n #3 , debe usar pthread_cond_broadcast .
Segundo: La configuración es válida (con transmisión). Los subprocesos #2 y #3 están programados para activarse e intentarán volver a adquirir la exclusión mutua como parte de la activación. Uno de ellos lo hará, el otro tendrá que esperar a que el mutex se desbloquee nuevamente. Entonces, los subprocesos n #2 y n #3 acceden a la sección crítica secuencialmente (para volver a evaluar la condición).
Si entiendo correctamente, desea que thr # 2 y thr # 3 ("trabajadores") se bloqueen hasta que thr # 1 ("jefe") haya realizado alguna inicialización.
Su enfoque es casi viable, pero necesita transmitir en lugar de señalar, y le falta una variable de predicado separada de su variable de condición. (En la pregunta a la que hace referencia, las variables de predicado y condición tenían un nombre muy similar). Por ejemplo:
pthread_mutex_t mtx; pthread_cond_t cv; int initialized = 0; // our predicate of interest, signaled via cv ... // boss thread initialize_things(); pthread_mutex_lock(&mtx); initialized = 1; pthread_cond_broadcast(&cv); pthread_mutex_unlock(&mtx); ... // worker threads pthread_mutex_lock(&mtx); while (! initialized) { pthread_cond_wait(&cv, &mtx); } pthread_mutex_unlock(&mtx); do_things(); Eso es lo suficientemente común como para que desee combinar mutex/cv/flag en una sola abstracción. (Para obtener inspiración, consulte Objeto de evento de Python). Barreras POSIX que son otra forma de sincronizar subprocesos: cada subproceso espera hasta que todos los subprocesos "llegan". pthread_once es otra forma, ya que ejecuta una función una vez y solo una vez, sin importar cuántos hilos la llamen.
pthread_cond_signal activa un subproceso (aleatorio) que espera en la variable cond . Si desea activar todos los subprocesos que esperan en esta variable cond , use pthread_cond_broadcast .