条件变量

@小棋童

已于 2023-04-03 12:04:05 修改

阅读量581

点赞数 3

分类专栏： Linux系统编程笔记文章标签： linux c++ 服务器运维

于 2023-04-02 15:57:39 首次发布

本文链接：https://blog.csdn.net/weixin_43200943/article/details/129911396

版权

Linux系统编程笔记专栏收录该内容

17 篇文章 1 订阅

订阅专栏

条件变量是一种线程同步机制，常与互斥锁配合使用，用于实现“等待-唤醒”逻辑。当条件不满足时，线程会释放互斥锁并等待；当条件满足，通过条件变量唤醒线程。文中给出了使用pthread库的条件变量实现生产者消费者模型的例子，展示了如何通过条件变量减少不必要的线程竞争，提高程序效率。

摘要由CSDN通过智能技术生成

基本概念：

条件变量是利用线程间共享的变量进行同步的一种机制，是在多线程程序中用来实现"等待–>唤醒"逻辑常用的方法，用于维护一个条件(与是条件变量不同的概念)，线程可以使用条件变量来等待某个条件为真，注意理解并不是等待条件变量为真。

当条件不满足时，线程将自己加入等待队列，同时释放持有的互斥锁；当一个线程唤醒一个或多个等待线程时，此时条件不一定为真(虚假唤醒)。

条件变量本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。

条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。

主要应用函数：

pthread_cond_init函数
pthread_cond_destroy函数
pthread_cond_wait函数
pthread_cond_timedwait函数
pthread_cond_signal函数
pthread_cond_broadcast函数

以上6 个函数的返回值都是：成功返回0，失败直接返回错误号。

pthread_cond_t类型用于定义条件变量

pthread_cond_t cond;

pthread_cond_init函数

初始化一个条件变量

        int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

        参2：attr表条件变量属性，通常为默认值，传NULL即可

        也可以使用静态初始化的方法，初始化条件变量：

                pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

pthread_cond_destroy函数

销毁一个条件变量

int pthread_cond_destroy(pthread_cond_t *cond);

pthread_cond_wait函数

阻塞等待一个条件变量

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

函数作用：

阻塞等待条件变量cond（参1）满足
释放已掌握的互斥锁（解锁互斥量）相当于pthread_mutex_unlock(&mutex); 以上两步为一个原子操作。
当被唤醒，pthread_cond_wait函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);

pthread_cond_timedwait函数

限时等待一个条件变量

        int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);

        参3：参看man sem_timedwait函数，查看struct timespec结构体。

                struct timespec {

                                time_t tv_sec;          /* seconds */ 秒

                                long   tv_nsec;      /* nanosecondes*/ 纳秒

                }

        形参 abstime：绝对时间。

pthread_cond_signal函数

唤醒至少一个阻塞在条件变量上的线程

int pthread_cond_signal(pthread_cond_t *cond);

pthread_cond_broadcast函数

唤醒全部阻塞在条件变量上的线程

int pthread_cond_broadcast(pthread_cond_t *cond);

生产者消费者条件变量模型

线程同步典型的案例即为生产者消费者模型，而借助条件变量来实现这一模型，是比较常见的一种方法。假定有两个线程，一个模拟生产者行为，一个模拟消费者行为。两个线程同时操作一个共享资源（一般称之为汇聚），生产向其中添加产品，消费者从中消费掉产品。

https://www.bilibili.com/video/BV1KE411q7ee?p=178&spm_id_from=pageDriver&vd_source=d239c7cf48aa4f74eccfa736c3122e65https://www.bilibili.com/video/BV1KE411q7ee?p=178&spm_id_from=pageDriver&vd_source=d239c7cf48aa4f74eccfa736c3122e65

/*借助条件变量模拟 生产者-消费者问题*/
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>

/*链表作为共享数据，需要被互斥量保护*/
struct msg {
    struct msg *next;
    int num;
};

struct msg *head;

/*静态初始化 一个条件变量 和 一个互斥量*/
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void *consumer(void *p)
{
    struct msg *mp;
    while(1) {
        pthread_mutex_lock(&lock);
        while (head == NULL) {           //头指针为空,说明没有节点  可以为if吗
            pthread_cond_wait(&has_product, &lock); //阻塞等待
        }
        mp = head;      
        head = mp->next;    			//模拟消费掉一个产品
        pthread_mutex_unlock(&lock);

        printf("-Consume ---%d\n", mp->num);
        free(mp); //malloc
        sleep(rand() % 5); //给对端获取CPU的机会
    }
}
void *producer(void *p)
{
    struct msg *mp;
    while (1) {
        mp = malloc(sizeof(struct msg)); //free
        mp->num = rand() % 1000 + 1;        //模拟生产一个产品
        printf("-Produce -----------------%d\n", mp->num);

        pthread_mutex_lock(&lock);
        mp->next = head; //头插法
        head = mp;
        pthread_mutex_unlock(&lock);

        pthread_cond_signal(&has_product);  //将等待在该条件变量上的一个线程唤醒
        sleep(rand() % 5);
    }
}
int main(int argc, char *argv[])
{
    pthread_t pid, cid;
    srand(time(NULL));

    pthread_create(&pid, NULL, producer, NULL);
    pthread_create(&cid, NULL, consumer, NULL);

    pthread_join(pid, NULL);
    pthread_join(cid, NULL);
    return 0;
}

一个生产者，多个消费者

/*借助条件变量模拟 生产者-消费者问题*/
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include<errno.h>

void err_thread(int ret, char *str)
{
    if(ret != 0){
        fprintf(stderr, "%s\n", str, strerror(ret));
        pthread_exit(NULL);
    }
}

struct msg
{
    int num;
    struct msg *next;
};

struct msg *head;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //定义并初始化互斥量
pthread_cond_t has_data = PTHREAD_COND_INITIALIZER; //定义并初始化条件变量

void *producer(void *arg)
{
    while(1){

        struct msg *mp = malloc(sizeof(struct msg));

        mp->num = rand()%1000+1;           //模拟生产一个数据
        printf("---producer---------- %d\n", mp->num);
    
        pthread_mutex_lock(&mutex); //写公共区域  把数据加入公共区域，需要加锁
        mp->next = head; //头插法
        head = mp;
        pthread_mutex_unlock(&mutex);  //解锁

        pthread_cond_signal(&has_data);  //唤醒阻塞在条件变量has_data上的线程，即生产者

        sleep(rand()%3);
    }

    return NULL;
}

void *consumer(void *arg)
{
    while(1){

        struct msg *mp;

        pthread_mutex_lock(&mutex); //加锁  互斥量
        //if(head == NULL){ //一个生产者一个消费者，可用if
        while(head == NULL){ //多个消费者，要用while
            pthread_cond_wait(&has_data, &mutex); //阻塞等待条件变量，解锁
        }                                         //pthread_cond_wait 返回时，重新加锁 mutex

        mp = head;
        head = mp->next;

        pthread_mutex_unlock(&mutex);  //解锁 互斥量
        printf("---consumer id:---- %lu\ :%d\n", pthread_self(), mp->num);

        free(mp);

        sleep(rand()%3);
    }

    return NULL;
}

int main(int argc, char *argv[])
{
    int ret;
    pthread_t pid, cid;

    srand(time(NULL));

    ret = pthread_create(&pid, NULL, producer, NULL); //生产者
    if(ret != 0){
        err_thread(ret, "pthread_create producer error");
    }

    pthread_create(&cid, NULL, consumer, NULL); //消费者
    if(ret != 0){
        err_thread(ret, "pthread_create consumer error");
    }
    pthread_create(&cid, NULL, consumer, NULL); //消费者
    if(ret != 0){
        err_thread(ret, "pthread_create consumer error");
    }
    pthread_create(&cid, NULL, consumer, NULL); //消费者
    if(ret != 0){
        err_thread(ret, "pthread_create consumer error");
    }

    pthread_join(pid, NULL); //回收线程
    pthread_join(cid, NULL);

    return 0;
}

条件变量的优点

相较于mutex而言，条件变量可以减少竞争。

如直接使用mutex，除了生产者、消费者之间要竞争互斥量以外，消费者之间也需要竞争互斥量，但如果汇聚（链表）中没有数据，消费者之间竞争互斥锁是无意义的。有了条件变量机制以后，只有生产者完成生产，才会引起消费者之间的竞争。提高了程序效率。

条件变量理解总结

条件变量的作用 - 线程同步
手段： 条件变量控制的是线程的挂起与唤醒，所使用的主要相关函数是 “唤醒” 和 “等待”。

假如没有“条件变量”这个概念，如果一个线程要等待某个“自定义的条件”满足而继续执行，而这个条件只能由另一个线程来满足

个人理解

两个线程利用条件变量及互斥锁实现同步。条件变量和互斥锁对两个线程来说是全局的。
一个线程利用条件变量实现等待，同时释放锁；
一个线程获取锁后利用该条件变量唤醒等待的线程。

互斥锁+条件变量

互斥锁主要用来共享资源上，而条件变量主要用来在满足条件时通知线程

互斥锁就是保证线程间读写某个数值时的原子性，在执行操作时不会切换到其他线程，实现了原子操作(连续不间断),解决了一些资源竞争问题。

为什么条件变量经常要配合互斥量 mutex 一起合作？

因为有时会有许多线程被唤醒，这些线程都会同时要求访问共享资源，因此需要 mutex 来保护共享资源。

1. 这是为了应对线程1在调用pthread_cond_wait()但线程1还没有进入wait cond的状态的时候，此时线程2调用了 cond_singal 的情况。如果不用mutex锁的话，这个cond_singal就丢失了。加了锁的情况是，线程2必须等到 mutex 被释放（也就是 pthread_cod_wait() 释放锁并进入wait_cond状态，此时线程2上锁）的时候才能调用cond_singal。

2. 保证了只有一个线程基于条件变量阻塞

简而言之就是，在thread 1 call pthread_cond_wait() 的时刻到 thread 1真正进入 wait 状态时，是存在着时间差的。如果在这段时间差内 thread2 调用了 pthread_cond_signal() 那这个 signal 信号就丢失了。给 wait 加锁可以防止同时有另一个线程在 signal