Fundamentos del sistema operativo de la computadora (14) --- Variables de condición para la sincronización de subprocesos

Introducción

Este artículo es el decimocuarto artículo, la variable de condición de la sincronización de subprocesos . En el artículo anterior, presenté el bloqueo de lectura-escritura. El rendimiento del bloqueo de lectura-escritura es mejor que el mutex bajo la condición de más lectura y menos escritura. Este artículo presenta un método importante para procesar variables de condición de sincronización de subprocesos

Variable de condición

• Las variables de condición son un método de sincronización de subprocesos relativamente complejo
• Las variables de condición permiten que el hilo duerma hasta que se cumpla una determinada condición
• Cuando se cumplen las condiciones, puede enviar una señal al hilo para notificar al hilo que se despierte

Para el modelo productor-consumidor presentado anteriormente, en realidad existen algunas lagunas

• Cuando el búfer es menor que 0, los consumidores no pueden consumir y los consumidores deben esperar
• Cuando el búfer está lleno, el productor no puede producir en el búfer, el productor debe esperar

En el artículo anterior, no hay ninguna restricción sobre esto. Al estudiar las variables condicionales en este artículo, esto será más rigurosamente restringido.

Suponiendo que el búfer es igual a 0 en este momento, cuando el productor produce un producto, despierta a los consumidores que pueden estar esperando . Suponga que cuando el búfer está lleno, cuando un consumidor consume un producto, despierta al productor que puede estar esperando

Ejemplo de variable de condición (debe usarse con mutex)

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<vector>
#include<queue>

//临界资源
int num=0;
//缓冲区最大值
int MAX_BUF=100;
//定义条件变量
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
//定义互斥量
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;

void* producer(void*){
    while(true){
        pthread_mutex_lock(&mutex);
        while(num>=MAX_BUF){
            //等待
            pthread_cond_wait(&cond, &mutex);
            printf("缓冲区满了，等待消费者消费\n");
        }
        num+=1;
        printf("生产一个产品，当前产品数量为：%d", num);
        sleep(1);//生产产品所需时间
        //通知可能等待的消费者
        pthread_cond_signal(&cond);
        printf("通知消费者...\n");
        //解锁
        pthread_mutex_unlock(&mutex);
        sleep(1);生产产品的频率
    }
}

void* consumer(void*){
    while(true){
        pthread_mutex_lock(&mutex);
        while(num<=0){
            //等待
            pthread_cond_wait(&cond, &mutex);
       printf("缓冲区空了，等待生产者生产\n");     
        }
        num-=1;
        printf("消费一个产品，当前产品数量为：%d", num);
        sleep(1);
        //通知可能等待的生产者
        pthread_cond_signal(&cond);
        printf("通知生产者...\n");
        //解锁
        pthread_mutex_unlock(&mutex);
    }
}

int main()
{
        //定义两个线程
        pthread_t thread1,thread2;
        //一个执行生产者逻辑，一个执行消费者逻辑
        pthread_create(&thread1, NULL, &producer, NULL);
        pthread_create(&thread2, NULL, &consumer, NULL);
        pthread_join(&thread1, NULL);
        pthread_join(&thread2, NULL);
        
        return 0;
}

Resultados de:

Es la competitividad central de una persona técnica encontrar la constante en la tecnología que cambia rápidamente. Unidad de conocimiento y acción, combinando teoría con práctica