Principes de base du système d'exploitation informatique (14) --- Variables de condition pour la synchronisation des threads

introduction

Cet article est le quatorzième article, la variable de condition de la synchronisation des threads . Dans l'article précédent, j'ai présenté le verrou en lecture-écriture. Les performances du verrou en lecture-écriture sont meilleures que celles du mutex à condition de lire et d'écrire moins. Cet article présente une méthode importante de traitement des variables de condition de synchronisation des threads

Variable de condition

• Les variables de condition sont une méthode de synchronisation de threads relativement complexe
• Les variables de condition permettent au thread de dormir jusqu'à ce qu'une certaine condition soit remplie
• Lorsque les conditions sont remplies, vous pouvez envoyer un signal au thread pour avertir le thread de se réveiller

Pour le modèle producteur-consommateur présenté ci-dessus, il existe en fait des failles

• Lorsque la mémoire tampon est inférieure à 0, les consommateurs ne sont pas autorisés à consommer et les consommateurs doivent attendre
• Lorsque le tampon est plein, le producteur n'est pas autorisé à produire vers le tampon, le producteur doit attendre

Dans l'article précédent, il n'y a aucune restriction à ce sujet. Lors de l'étude des variables conditionnelles dans cet article, cela sera plus rigoureusement limité.

En supposant que le tampon est égal à 0 à ce moment, lorsque le producteur produit un produit, réveillez les consommateurs qui peuvent attendre . Supposons que lorsque le tampon est plein, lorsqu'un consommateur consomme un produit, réveille le producteur qui attend peut-être

Exemple de variable de condition (doit être utilisé avec 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;
}

Résultats du:

C'est la compétitivité de base d'une personne technique pour trouver la constante dans la technologie en évolution rapide. Unité de connaissance et d'action, alliant théorie et pratique