Seguridad del hilo ---- variables de condición

variable de condición

      Las variables de condición son otro mecanismo mutex de sincronización con una lógica un poco más complicada y deben usarse junto con bloqueos mutex.

Sus escenarios de aplicación también son muy comunes, veamos primero un ejemplo:

 

     Xiaonan es estudiante en la escuela y recibe un subsidio de subsistencia de sus padres todos los meses. Ahora que se le acabó el dinero, piensa

Voy a retirar dinero. Pero obviamente retirar dinero no es algo que puedas hacer si quieres, ¡la premisa es que debe haber dinero en la tarjeta! En

Fue Xiaonan quien tomó su teléfono y lo comprobó: el saldo era ￥ 0 . Ahora además de mirar fijamente, lo único que puede hacer puede ser una cosa:

esperar. Espere hasta que sus padres hayan transferido el dinero y la llamen para informarle.

       

      Pero además, incluso si sus padres le enviaran el dinero y la llamaran para avisarle, no podía garantizar que lo recibiría en ese momento.

dinero, porque al mismo tiempo, sus muchos hermanos y hermanas (todos compartiendo una cuenta bancaria) pueden haber sido los primeros en recibir el dinero.

¡Cuéntalos todos! Por lo tanto, cuando Xiaonan recibió una llamada de sus padres, necesitaba confirmar nuevamente si tenía dinero antes de poder retirarlo.

      En la figura anterior, una vez que el hilo encuentra que el saldo es 0 , entrará en suspensión de espera y, al mismo tiempo, primero debe liberar el bloqueo mutex, como

Si te acuestas con candado nadie podrá modificar el saldo y todos quedarán bloqueados indefinidamente, al contrario nadie podrá modificar el saldo.

Cuando espere salir de la cola, primero debe mantener el bloqueo mutex, porque necesita acceder al saldo de recursos compartidos inmediatamente después de salir.

   

     Preste especial atención al hecho de que hay dos bloqueos dentro del marco, lo que significa que cuando un hilo entra en el estado de espera de una determinada variable de condición,

Al esperar en la cola de espera y salir de la cola de espera, el desbloqueo y bloqueo del mutex se completan automáticamente.

Esta es la razón por la que las variables de condición y los bloqueos mutex se utilizan juntos.

#include<stdio.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

pthread_cond_t cond;
pthread_mutex_t lock;
int num=0;
void *function(void *arg)
{
    char *msg=(char *)arg;
   
     while (1)
   {
   
    if (num<100)
    {
      pthread_mutex_lock(&lock);
      printf("%s添加互斥锁成功！准备取钱\n",msg);
        //如果金额不足，则会进入条件变量的队列中等待
        //进入之前该函数会帮我们把lock互斥锁解开，以便存钱
       pthread_cond_wait(&cond, &lock);
    }
    num-=100;
    printf("我是%s号线程,目前余额%d\n",msg,num);
      pthread_mutex_unlock(&lock);
      sleep(10);   
  }
}

int main(int argc, char const *argv[])
{
    //初始化条件变量 
    pthread_cond_init(&cond, NULL);

    //初始化互斥锁 
     pthread_mutex_init(&lock,NULL);

    pthread_t thread1;
    pthread_t thread2;
    pthread_t thread3;
    pthread_t thread4;
     pthread_create(&thread1, NULL,function, "1");   
     pthread_create(&thread2, NULL,function, "2");   
     pthread_create(&thread3, NULL,function, "3"); 
     pthread_create(&thread4, NULL,function, "4"); 

     while (1)
     {
       //作为父母，时刻关注账号中的金钱
       if(num<100)
       {
          printf("余额不足，准备转帐！\n");
          pthread_mutex_lock(&lock);
          printf("main添加互斥锁成功！\n");
                    //如果小于100，自觉存钱
                    num+=100;
                    printf("微信转账100块\n");
            pthread_mutex_unlock(&lock);
          pthread_cond_signal(&cond);
          printf("成功唤醒所有孩子！\n");
        
          printf("解锁.....\n");
          sleep(1);
       }
     }

    return 0;
}