实现同步与互斥的一个实例--生产者消费模型

1.基础知识

 1).生产者消费模型中存在3种关系：

    a.生产者与生产者之间是互斥的；

    b.消费者与消费者之间是互斥的；

    c.生产者与消费者之间是同步与互斥的；

 2).生产者与消费者的场所，这儿我们选择单链表。

2.内容：a.单生产者生产一个结构体串在链表的表尾上,单消费者从表头取走结构体

 代码实现

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<pthread.h>
  4 
  5 typedef struct list
  6 {
  7     int _data;
  8     struct list* _next;
  9 }product_list;
 10 product_list* head=NULL;
 11 
 12 static pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;  //加锁
 13 static pthread_cond_t need_product=PTHREAD_COND_INITIALIZER;
 14 
 15 product_list* createNode(int data)
 16 {
 17     product_list* tmp=malloc(sizeof(product_list));
 18     tmp->_data=data;
 19     tmp->_next=NULL;
 20     return tmp;
 21 }
 22 void InitList(product_list** pHead)  //&引用
 23 {
 24     *pHead=createNode(0);
 25 }
 26 int PushBack(product_list* pHead,int data)
 27 {
 28         product_list* tail=pHead;
 29         while(tail->_next!=NULL)
 30         {
 31             tail=tail->_next;
 32         }
 33         product_list* new=createNode(data);
 34         tail->_next=new;
 35         return new->_data;
 36 }
 37 int PopFront(product_list* pHead)
 38 {
 39         product_list* tmp=pHead->_next;
 40     //  product_list* tmp=pHead;
 41         pHead->_next=pHead->_next->_next;
 42         pHead=pHead->_next;
 43         tmp->_next=NULL;  //易忘
 44         int val=tmp->_data;
 45         free(tmp);  //易忘
 46         tmp=NULL;
 47         return val;
 48 }
 49 void* product(void* arg)
 50 {
 51     int i=0;
 52     for(;i<10;i++)
 53     {
 54         pthread_mutex_lock(&lock);
 55         int val=PushBack(head,i);
 56         pthread_mutex_unlock(&lock);
 57         printf("call consumer!product success!product data is:%d\n",val);
 58         pthread_cond_signal(&need_product);
 59         sleep(2);
 60     }
 61 }
 62 void* consumer(void* arg)
 63 {
 64     while(1)
 65     {
 66         pthread_mutex_lock(&lock);
 67         while(head->_next==NULL)
 68         {
 69             pthread_cond_wait(&need_product,&lock);
 70         }
 71         int val=PopFront(head);
 72         pthread_mutex_unlock(&lock);
 73         printf("comsumer success!consumer data is:%d\n",val);
 74         sleep(4);
 75     }
 76     return NULL;
 77 }
 78 int main()
 79 {
 80     InitList(&head);
 81     pthread_t product1;
 82     pthread_t consumer1;
 83 
 84     pthread_create(&product1,NULL,product,NULL);
 85     pthread_create(&consumer1,NULL,consumer,NULL);
 86 
 87     pthread_join(product1,NULL);
 88     pthread_join(consumer1,NULL);
 89 
 90     return 0;
 91 }

输出结果：

b.多生产者生产一个结构体串在链表的表尾上,多消费者从表头取走结构体。

代码实现

//test.c
  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<pthread.h>
  4 
  5 typedef struct list
  6 {
  7     int _data;
  8     struct list* _next;
  9 }product_list;
 10 product_list* head=NULL;
 11 
 12 static pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;//jia suo
 13 static pthread_cond_t need_product=PTHREAD_COND_INITIALIZER;
 14 
 15 product_list* createNode(int data)
 16 {
 17     product_list* tmp=malloc(sizeof(product_list));
 18     tmp->_data=data;
 19     tmp->_next=NULL;
 20     return tmp;
 21 }
 22 void InitList(product_list** pHead)//&yingyong
 23 {
 24     *pHead=createNode(0);
 25 }
 26 int PushBack(product_list* pHead,int data)
 27 {
 28         product_list* tail=pHead;
 29         while(tail->_next!=NULL)
 30         {
 31             tail=tail->_next;
 32         }
 33         product_list* new=createNode(data);
 34         tail->_next=new;
 35         return new->_data;
 36 }
 37 int PopFront(product_list* pHead)
 38 {
 39     product_list* tmp=pHead->_next;
 40     pHead->_next=pHead->_next->_next;
 41     pHead=pHead->_next;
 42     tmp->_next=NULL;//
 43     int val=tmp->_data;
 44     free(tmp);//
 45     tmp=NULL;
 46     return val;
 47 }
 48 void* product(void* arg)
 49 {
 50     int i=0;
 51     for(;i<10;i++)
 52     {
 53         pthread_mutex_lock(&lock);
 54         int val=PushBack(head,i);
 55         pthread_mutex_unlock(&lock);
 56         printf("call consumer!product%s success!product data is:%d\n",(char*)arg,val);
 57         pthread_cond_broadcast(&need_product);
 58         sleep(1);
 59     }
 60 }
 61 void* consumer(void* arg)
 62 {
 63     while(1)
 64     {
 65         pthread_mutex_lock(&lock);
 66         while(head->_next==NULL)
 67         {
 68             pthread_cond_wait(&need_product,&lock);
 69         }
 70         int val=PopFront(head);
 71         pthread_mutex_unlock(&lock);
 72         printf("comsumer success!consumer%s data is:%d\n",(char*)arg,val);
 73     //  sleep(2);
 74     }
 75 }
 76 int main()
 77 {
 78     InitList(&head);
 79     pthread_t product1;
 80     pthread_t product2;
 81     pthread_t product3;
 82     pthread_t consumer1;
 83     pthread_t consumer2;
 84     pthread_t consumer3;
 85 
 86     char* p1="1";
 87     char* p2="2";
 88     char* p3="3";
 89 
 90     pthread_create(&product1,NULL,product,(void*)p1);
 91     pthread_create(&product2,NULL,product,(void*)p2);
 92     pthread_create(&product3,NULL,product,(void*)p3);
 93     pthread_create(&consumer1,NULL,consumer,(void*)p1);
 94     pthread_create(&consumer2,NULL,consumer,(void*)p2);
 95     pthread_create(&consumer3,NULL,consumer,(void*)p3);
 96 
 97     pthread_join(product1,NULL);
 98     pthread_join(product2,NULL);
 99     pthread_join(product3,NULL);
100     pthread_join(consumer1,NULL);
101     pthread_join(consumer2,NULL);
102     pthread_join(consumer3,NULL);
103 
104     return 0;
105 }

//makefile
  1 test:test.c
  2     gcc -o $@ $^ -lpthread
  3 .PHONY:clean
  4 clean:
  5     rm -f test

输出结果：

把consumer中的sleep（2）注释，则，消费者消费会加快，但它会跟随成产者的生产的步伐，结果如下：

3.总结：

   1）a,b主要就是生产者通知的方式不同，单生产者单消费者采用pthread_cond_signal，多生产者多消费者采用pthread_cond_broadcast

   2)生产者消费模型，它们访问临界资源--产品的操作必须是互斥的，且操作为原子操作，否则会发生访问冲突，如上篇我们所验证的，最终得到结果和我们所预测的有很大差别，所以我们加入了互斥锁

  3）为了提高效率，我们引入了条件变量，即实现生产者每生产出了一件产品，就通知消费者过来取数据，反过来，消费者每消费完一件产品就告诉生产者，这样就提高了效率实现了线程之间的顺序性，实现同步

疑问：忘了pthread_mutex_destroy(&lock);

是product（）destroy一次就够了，还是product（）和consumer（）两个都要

转载于:https://blog.51cto.com/10707460/1766910