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

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（）两个都要