线程同步中，条件变量和互斥量如何一起使用。

旧城等待， 2022-01-07 12:09 250阅读 0赞

本片文章属于转载，原文出处：[https://www.cnblogs.com/lang5230/p/5686868.html][https_www.cnblogs.com_lang5230_p_5686868.html]。

## 多线程代码问题描述 ##

我们都知道，进程是操作系统对运行程序资源分配的基本单位，而线程是程序逻辑，调用的基本单位。在多线程的程序中，多个线程共享临界区资源，那么就会有问题：

比如

#include <pthread.h>
    #include <unistd.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int g_val = 10;
    void * test1(void* args)
    {
        g_val = 20;
        printf("in %s: g_val = %d\n",__func__, g_val);
    }
    void * test2(void* args)
    {
        sleep(1);
        printf("in %s: g_val = %d\n",__func__,g_val);
    }
    int main(int argc, char const *argv[])
    {
        pthread_t id1,id2;
        pthread_create(&id1,NULL,test1,NULL);
        pthread_create(&id2,NULL,test2,NULL);
        pthread_join(id1,NULL);
        pthread_join(id2,NULL);
        return 0;
    }

由次我们可以看到，线程1修改了全局变量，而线程2中页跟着改变了。

那么，对于这个问题进行放大，我们就会找到多线程存在的问题。如下

#include <stdio.h>
    #include <pthread.h>
    // pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    int g_val = 0;
    void* add(void *argv)
    {
        for(int i = 0 ; i < 5000; ++i)
        {
            // g_val++;
            // pthread_mutex_lock(&lock);
            int tmp = g_val;
            g_val = tmp+1;
            // pthread_mutex_unlock(&lock);
        }
    }
    
    int main(int argc, char const *argv[])
    {
        pthread_t id1,id2;
    
        pthread_create(&id1,NULL,add,NULL);
        pthread_create(&id2,NULL,add,NULL);
    
        pthread_join(id1,NULL);
        pthread_join(id2,NULL);
    
        printf("%d\n",g_val);
        return 0;
    }

![835234-20160720015018529-308930277.png][]

在上面代码中，我们执行两个线程分别对全局变量累加5000次，但是得到的结果却是不确定的。这是因为，在多线程程序中，线程调度使得线程间进行切换执行，如果当线程1将数据从内存读入cpu正在准备累加时，调度器切换线程2执行，此时，线程2获取的值是未累加的。那么，当两个线程都执行完本次累加后，实际值只增加了1。所以就会产生多次执行，结果不确定性。

注：代码中没有直接g\_val++,而选择了tmp过度就是为了产生非原子操作，让调度过程处于累加未完时。

那么解决这个问题，就需要互斥操作了。

我们首先来谈互斥量mutex

通过互斥量实现线程锁，在每个线程累加之前，进行临界资源的锁操作，在结束时解锁，那么就能保证目标的实现了。

#include <stdio.h>
    #include <pthread.h>
    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    int g_val = 0;
    void* add(void *argv)
    {
        for(int i = 0 ; i < 5000; ++i)
        {
            // g_val++;
            pthread_mutex_lock(&lock);
            int tmp = g_val;
            g_val = tmp+1;
            pthread_mutex_unlock(&lock);
        }
    }
    
    int main(int argc, char const *argv[])
    {
        pthread_t id1,id2;
    
        pthread_create(&id1,NULL,add,NULL);
        pthread_create(&id2,NULL,add,NULL);
    
        pthread_join(id1,NULL);
        pthread_join(id2,NULL);
    
        printf("%d\n",g_val);
        return 0;
    }

![835234-20160720015949076-1127991684.png][]

关于互斥锁的实现，在linux中实现如下

![835234-20160720020451935-684188325.png][]

## 条件变量 ##

问题场景描述

假设我们现在需要做一个生产者消费者模型，生产者对带有头节点的链表头插方式push\_front生产数据，消费者调用pop\_front消费数据.而生产者可能动作比较慢，这时就会有问题。

生产者生产一个数据时间，消费者可能迫切需求。因此，一直轮寻申请锁资源，以便进行消费。所以就会产生多次不必的锁资源申请释放动作。影响系统性能。

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <pthread.h>
    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
    typedef struct node 
    {
        int _data;
        struct node *_next;
    }node_t,* node_p,**node_pp;
    
    node_p head = NULL;
    
    node_p alloc_node(int data)
    {
        node_p ret = (node_p)malloc(sizeof(node_t));
        ret->_data = data;
        ret->_next = NULL;
        return ret;
    }
    
    void init(node_pp phead)
    {
        *phead = alloc_node(0);
    }
    
    void push_front(node_p head,int data)
    {
        node_p tmp = alloc_node(data);
        tmp->_next = head->_next;
        head->_next = tmp;
    }
    
    void pop_front(node_p head, int * pdata)
    {
        if(head->_next!=NULL)
        {
            node_p tmp = head->_next;
            head->_next = tmp->_next;
    
            *pdata = tmp->_data;
            free(tmp);        
        }
    }
    
    void show(node_p head)
    {
        node_p cur = head->_next;
        while(cur)
        {
            printf("%d->", cur->_data);
            cur = cur->_next;
        }
        printf("\n");
    }
    
    //消费者
    void * consumer(void *argv)
    {
        int data;
        while(1)
        {
            pthread_mutex_lock(&lock);
            // while(head->_next==NULL)
            if(head->_next==NULL)
            {
                printf("producter is not ready\n");
                // pthread_cond_wait(&cond,&lock);
                // break;
            }
            else{
            printf("producter is ready...\n");
            pop_front(head,&data);
            printf("%s  data = %d \n",__func__, data);
            }
            pthread_mutex_unlock(&lock);
    
            sleep(1);
        }
    }
    
    void * producter(void * argv)
    {
        int data = rand()%1234;
        while(1)
        {
            sleep(4);
            pthread_mutex_lock(&lock);
            push_front(head,data);
            printf("%s data :: %d\n",__func__, data);
            pthread_mutex_unlock(&lock);
            // pthread_cond_signal(&cond);
        }
    }
    
    int main(int argc, char const *argv[])
    {
        init(&head);
    
        pthread_t id1,id2;
        
        pthread_create(&id1,NULL,consumer,NULL);
        pthread_create(&id2,NULL,producter,NULL);
    
        pthread_join(id1,NULL);
        pthread_join(id2,NULL);
    }

![835234-20160720020946982-1337685816.png][]

由上，我们发现。生产者生叉一个数据之后，消费者总是会多次进行锁资源申请并尝试消费数据。那么，解决这一问题的方案就是：条件变量。

具体实现如下：

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <pthread.h>
    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
    typedef struct node 
    {
        int _data;
        struct node *_next;
    }node_t,* node_p,**node_pp;
    
    node_p head = NULL;
    
    node_p alloc_node(int data)
    {
        node_p ret = (node_p)malloc(sizeof(node_t));
        ret->_data = data;
        ret->_next = NULL;
        return ret;
    }
    
    void init(node_pp phead)
    {
        *phead = alloc_node(0);
    }
    
    void push_front(node_p head,int data)
    {
        node_p tmp = alloc_node(data);
        tmp->_next = head->_next;
        head->_next = tmp;
    }
    
    void pop_front(node_p head, int * pdata)
    {
        if(head->_next!=NULL)
        {
            node_p tmp = head->_next;
            head->_next = tmp->_next;
    
            *pdata = tmp->_data;
            free(tmp);        
        }
    }
    
    void show(node_p head)
    {
        node_p cur = head->_next;
        while(cur)
        {
            printf("%d->", cur->_data);
            cur = cur->_next;
        }
        printf("\n");
    }
    
    //消费者
    void * consumer(void *argv)
    {
        int data;
        while(1)
        {
            pthread_mutex_lock(&lock);
            while(head->_next==NULL)
            // if(head->_next==NULL)
            {
                printf("producter is not ready\n\n");
                pthread_cond_wait(&cond,&lock);
                break;
            }
            // else{
            // printf("producter is ready...\n");
            pop_front(head,&data);
            printf("%s  data = %d \n",__func__, data);
            // }
            pthread_mutex_unlock(&lock);
    
            sleep(1);
        }
    }
    
    void * producter(void * argv)
    {
        int data = rand()%1234;
        while(1)
        {
            sleep(4);
            pthread_mutex_lock(&lock);
            push_front(head,data);
            printf("%s data :: %d\n",__func__, data);
            pthread_mutex_unlock(&lock);
            pthread_cond_signal(&cond); //条件变量v操作
        }
    }
    
    int main(int argc, char const *argv[])
    {
        init(&head);
    
        pthread_t id1,id2;
        
        pthread_create(&id1,NULL,consumer,NULL);
        pthread_create(&id2,NULL,producter,NULL);
    
        pthread_join(id1,NULL);
        pthread_join(id2,NULL);
    }

![835234-20160720021708216-906509432.png][]

由图可以看出，这下我们的消费者不再进行过多次没必要的轮寻访问，当生产者生产数据时，告诉消费者可以进行消费了，那么消费者进行消费。

其实这也就是著名的：好莱坞原则---不要打电话给我们，我们会通知你。

eg，在面试笔试中，我们不需要过度的紧张是否被录用，只需要在做到最大努力之后等着招聘方通知就好。

注：一个Condition Variable总是和一个Mutex搭配使用的。一个线程可以调用  
pthread\_cond\_wait在一一个Condition Variable上阻塞等待,这个函数做以下三步操作:  
1. 释放Mutex。  
2. 阻塞等待。  
3. 当被唤醒时,重新获得Mutex并返回。

[https_www.cnblogs.com_lang5230_p_5686868.html]: https://www.cnblogs.com/lang5230/p/5686868.html
[835234-20160720015018529-308930277.png]: /images/20211223/316f623ce7d0454ca3f48fc5d72d4b81.png
[835234-20160720015949076-1127991684.png]: /images/20211223/ce4184c6c7b44b40be90f1b571b2048f.png
[835234-20160720020451935-684188325.png]: /images/20211223/fe379c46c8ee4c7d814d546803fa6579.png
[835234-20160720020946982-1337685816.png]: /images/20211223/097c3b08a38f455da5e69ac85a407b3f.png
[835234-20160720021708216-906509432.png]: /images/20211223/811b04c3feb440b791559cbc4dfb7f97.png