Linux多线程──生产者消费者问题

题外话：

    生活在当下，一直努力。

    努力工作，积极生活，笑着去面对工作中的，生活中的每个问题。

    写给自己。

    这些是自己过去小半年的收获，也是自己对新的开始的一个期待。

    下面这个例子是转载的，连接地址：http://www.linuxidc.com/Linux/2012-07/65199.htm

    推荐大家访问原帖，这个网站也很不错，经常逛的。

    刚刚解决的问题就是参考这个例子，关于Linux多线程的生产者消费者网上还有个更流行的例子，我昨天晚上参照那个例子处理的，但问题太多了，但网上很多很多人转载那个例子。很幸运这个对我的问题有效，所以Mark一下这个帖子，说不定以后还需要用。   

生产者消费者问题

这是一个非常经典的多线程题目，题目大意如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。

程序：

1. // producer_consumer.cpp   
2. //   
3. // 有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，   
4. // 在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓   
5. // 冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消   
6. // 费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。   
7. //   
8.   
9. #include <pthread.h>   
10. #include <stdio.h>   
11. #include <stdlib.h>   
12. #include <unistd.h>   
13.   
14.   
15. const int BUFFER_LENGTH = 100;  
16. int buffer[BUFFER_LENGTH];  
17. int front = 0, rear = -1; // 缓冲区的前端和尾端   
18. int size = 0;  
19.   
20. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;  
21. pthread_cond_t empty_cond = PTHREAD_COND_INITIALIZER;  
22. pthread_cond_t full_cond = PTHREAD_COND_INITIALIZER;  
23.   
24. bool producer_wait = false;  
25. bool consumer_wait = false;  
26.   
27. void *producer(void *arg);  
28. void *consumer(void *arg);  
29.   
30. int main(int argc, char **argv)  
31. {  
32.     pthread_t producer_id;  
33.     pthread_t consumer_id;  
34.   
35.     pthread_create(&producer_id, NULL, producer, NULL);  
36.       
37.     pthread_create(&consumer_id, NULL, consumer, NULL);  
38.   
39.     sleep(1);  
40.   
41.     return 0;  
42. }  
43.   
44. void *producer(void *arg)  
45. {  
46.     pthread_detach(pthread_self());  
47.       
48.     while (true)  
49.     {  
50.         pthread_mutex_lock(&mutex);  
51.         if (size == BUFFER_LENGTH) // 如果缓冲区已满，等待; 否则，添加新产品   
52.         {  
53.             printf("buffer is full. producer is waiting...\n");  
54.             producer_wait = true;  
55.             pthread_cond_wait(&full_cond, &mutex);  
56.             producer_wait = false;  
57.         }  
58.         // 往尾端添加一个产品   
59.         rear = (rear + 1) % BUFFER_LENGTH;  
60.         buffer[rear] = rand() % BUFFER_LENGTH;  
61.         printf("producer produces the item %d: %d\n", rear, buffer[rear]);  
62.         ++size;  
63.         if (size == 1) // 如果当前size=1, 说明以前size=0, 消费者在等待，则给消费者发信号   
64.         {  
65.             while (true)  
66.             {  
67.                 if (consumer_wait)  
68.                 {  
69.                     pthread_cond_signal(&empty_cond);  
70.                     break;  
71.                 }  
72.             }  
73.         }  
74.         pthread_mutex_unlock(&mutex);  
75.     }  
76. }  
77.   
78. void *consumer(void *arg)  
79. {  
80.     pthread_detach(pthread_self());  
81.       
82.     while (true)  
83.     {  
84.         pthread_mutex_lock(&mutex);  
85.         if (size == 0) // 如果缓冲区已空，等待; 否则，消费产品   
86.         {  
87.             printf("buffer is empty. consumer is waiting...\n");  
88.             consumer_wait = true;  
89.             pthread_cond_wait(&empty_cond, &mutex);  
90.             consumer_wait = false;  
91.         }  
92.         // 从前端消费一个产品   
93.         printf("consumer consumes an item%d: %d\n", front, buffer[front]);  
94.         front = (front + 1) % BUFFER_LENGTH;  
95.         --size;  
96.         if (size == BUFFER_LENGTH-1) // 如果当前size=BUFFER_LENGTH-1，www.linuxidc.com说明以前生产者在等待，则给生产者发信号   
97.         {  
98.             while (true)  
99.             {  
100.                 if (producer_wait)  
101.                 {  
102.                     pthread_cond_signal(&full_cond);  
103.                     break;  
104.                 }  
105.             }  
106.         }  
107.         pthread_mutex_unlock(&mutex);  
108.     }  
109. }