Función pthread_cond_wait en c
Hay un tipo de sincronización que existe entre hilos llamados bloqueos. En este caso, el hilo necesita exclusión mutua. Requiere un hilo para ejecutar a la vez. Luego, también se requiere un patrón común cuando se interactúan múltiples hilos. Ellos están - esperando y señalización. Un hilo esperará hasta que otro hilo termine su trabajo. Después de completar la ejecución de este hilo, el hilo de espera puede ejecutarse en el procesador. Para este tipo de sincronización de hilos, necesitamos otra técnica, llamada ocupado esperando algunas variables. Para esto, necesitamos una nueva sincronización primitiva llamadas variables de condición.
Este concepto de hilo está disponible en diferentes sistemas operativos. Pero iremos al nombre, las variables de condición que se aplican como biblioteca PTHREAD en el sistema operativo Linux
La función pthread_cond_wait () es un componente de espera. Esta función de forma predeterminada realiza la acción de desbloqueo.
Programación Ejemplo-1:
En este ejemplo de programación veremos cómo se ejecuta esta función:
#incluir#incluir
#incluir
#incluir
#incluir
pthread_mutex_t m = pthread_mutex_initializer; // declarando la variable de condición.
pthread_cond_t c = pthread_cond_initializer;
int hecho = 0;
void thr_exit ()
pthread_mutex_lock (& m);
hecho = 1;
pthread_cond_signal (& c);
pthread_mutex_unlock (& m);
void *niño (void *arg) // El proceso del niño se ejecuta.
printf ("Child \ n");
thr_exit ();
regresar nulo;
Void thr_Join ()
pthread_mutex_lock (& m);
mientras (hecho == 0)
pthread_cond_wait (& c, & m); // llamar a la función dentro de la función thr_join ().
pthread_mutex_unlock (& m);
int main (int argc, char* argv [])
printf ("Parent: Begin \ n");
pthread_tp;
pthread_create (& p, nulo, niño, nulo); // Inicializando el hilo.
thr_Join ();
printf ("Parent: End \ n");
regresar 0;
Producción:
Explicación
En este ejemplo de programación existen dos procesos llamados hilo principal y un hilo infantil. Aquí, el padre quiere esperar al niño. Después de completar la ejecución del proceso infantil, los padres comienzan su ejecución.
Para el interior del main () creamos el hilo de los padres y el hijo. Child Thread ejecuta la función llamada Child (). Entonces el hilo principal llama a la función unirse. Este unión () básicamente verifica que el niño esté listo. De lo contrario, esperará usando la función pthread_cond_wait (). Cuando el niño corre, llama a la salida (). Cuando se realice la ejecución del niño, el valor de la variable realizado será 1. Luego, llama a la variable de la señal de la condición. Después de eso, la ejecución del hilo principal comenzará.
Espera y sintaxis de señal:
void thr_exit ()hecho = 1;
pthread_cond_signal (& c);
Void thr_Join ()
if (hecho == 0)
pthread_cond_wait (& c);
¿Qué pasa si no obtenemos un bloqueo?? Ocurrirá una condición de carrera - despertar perdido.
- El proceso de los padres no tiene nada para la ejecución e ir a la condición inactiva, para que se pueda ocurrir la interrupción del caso.
- Cuando el niño ejecuta su código y realizó su ejecución, entonces señala pero nadie durmiendo todavía.
- El padre ahora reinició su ejecución desde donde terminó y tiene que ser esperado por un período específico.
- Para esta función de espera debe tener en cuenta que el hilo no está suspendido por un período de tiempo más largo. Tiene que abrirse su bloqueo.
Programación Ejemplo-2:
En este ejemplo de programación veremos otro uso de pthread_cond_wait fuction.
#incluir#incluir
#incluir
#incluir
#incluir
pthread_mutex_tmutexfuel;
pthread_cond_tcondFuel; // Creando la variable de condición.
int Fuel = 0;
void* combustible (void* arg)
para (int i = 0; i < 5; i++)
pthread_mutex_lock (& mutexfuel);
combustible += 15;
printf ("Got Fuel ... %d \ n", combustible);
pthread_mutex_unlock (& mutexfuel);
pthread_cond_signal (& Condfuel);
dormir (1);
void* vehículo (void* arg)
pthread_mutex_lock (& mutexfuel);
mientras (combustible < 40)
printf ("cero combustible. Esperando ... \ n ");
pthread_cond_wait (& Condfuel, & mutexfuel);
// Equivalente a:
// pthread_mutex_unlock (& mutexfuel);
// Espere la señal en el Condfuel
// pthread_mutex_lock (& mutexfuel);
combustible -= 40;
printf ("combustible recolectado ahora izquierda: %d \ n", combustible);
pthread_mutex_unlock (& mutexfuel);
int main (int argc, char* argv [])
pthread_ta [2];
pthread_mutex_init (& mutexfuel, null);
pthread_cond_init (& Condfuel, nulo);
para (int i = 0; i < 2 ; i++ )
if (i == 1)
if (pthread_create (& a [i], nulo y combustible, nulo) != 0)
Perror ("Error al crear hilo");
demás
if (pthread_create (& a [i], null y vehículo, nulo) != 0)
Perror ("Error al crear hilo");
para (int i = 0; i < 2 ; i++ )
if (pthread_join (a [i], nulo) != 0)
Perror ("no pudo unirse al hilo");
pthread_mutex_destroy (& mutexfuel);
pthread_cond_destroy (& Condfuel); // destruyendo los hilos.
regresar 0;
Producción:
Explicación
Aquí, veremos la aplicación de la función pthread_cond_wait (). Es como cuando alguien quiere llenar el combustible su auto. Tiene que esperar hasta que su auto se llene de combustible. Para esto, creamos dos hilos. Uno para llenar el combustible en el automóvil y para el auto. Definiremos dos funciones. Una función de combustible () que determina cuándo llenar el automóvil con combustible y otra es la función de vehículo () para obtener combustible. El tipo que quiere llenar el combustible en su automóvil tiene que esperar hasta que el combustible se llene.
Dentro de la función Main () crearemos dos hilos para la función de combustible () y para vehículo (). Ahora, crearemos una variable de condición para esperar la condición. Para esto veremos la salida. Cuando las funciones completen su ejecución, destruiremos estos hilos.
Conclusión
La función pthread_cond_wait () notifica cuándo hemos hecho algún programa con la ayuda de múltiples hilos. Esta función hará algunas variables de condición para manejar estos hilos. En realidad, las características de esta función dependen totalmente del principio de esperar y señalar teoría.