【Linux】生产者消费者编程实现-线程池+信号量

生产者消费者编程实现，采用了线程池以及信号量技术。

线程的概念就不多说，首先说一下多线程的好处：多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。

那么为什么又需要线程池呢？

我们知道应用程序创建一个对象，然后销毁对象是很耗费资源的。创建线程，销毁线程，也是如此。因此，我们就预先生成一些线程，等到我们使用的时候在进行调度，于是，一些"池化资源"技术就这样的产生了。

一般一个简单线程池至少包含下列组成部分。

1)线程池管理器（ThreadPoolManager）:用于创建并管理线程池

2)工作线程（WorkThread）:线程池中线程

3)任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。

4)任务队列:用于存放没有处理的任务。提供一种缓冲机制。

图示：

图1 线程池图解

生产者消费者模型C语言代码实现：

thread_pool_pv.h：

[cpp] view plain copy print ?

1. //线程池编程实现
2. #ifndefTHREAD_POOL_H
3. #defineTHREAD_POOL_H
5. #include<stdio.h>
6. #include<stdlib.h>
7. #include<semaphore.h>//信号量sem_t
8. #include<pthread.h>
11. //任务接口,线程调用的函数
12. typedefvoid*(*FUNC)(void*arg);
14. //任务数据结构
15. typedefstructthread_pool_job_s{
16. FUNCfunction;//线程调用的函数
17. void*arg;//函数参数
18. structthread_pool_job_s*pre;//指向上一个节点
19. structthread_pool_job_s*next;//指向下一个节点
20. }thread_pool_job;
22. //工作队列
23. typedefstructthread_pool_job_queue_s{
24. thread_pool_job*head;//队列头指针
25. thread_pool_job*tail;//队列尾指针
26. intnum;//任务数目
27. sem_t*quene_sem;//信号量
28. }thread_pool_job_queue;
30. //线程池(存放消费者进程)
31. typedefstructthread_pool_s{
32. pthread_t*threads;//线程
33. intthreads_num;//线程数目
34. thread_pool_job_queue*job_queue;//指向工作队列的指针
35. }thread_pool;
37. //typedefstructthread_data_s{
38. //pthread_mutex_t*mutex_t;//互斥量
39. //thread_pool*tp_p;//指向线程池的指针
40. //}thread_data;
42. //初始化线程池
43. thread_pool*tp_init(intthread_num);
45. //初始化工作队列
46. inttp_job_quene_init(thread_pool*tp);
48. //向工作队列中添加一个元素
49. voidtp_job_quene_add(thread_pool*tp,thread_pool_job*new_job);
51. //向线程池中添加一个工作项
52. inttp_add_work(thread_pool*tp,void*(*func_p)(void*),void*arg);
54. //取得工作队列的最后个节点
55. thread_pool_job*tp_get_lastjob(thread_pool*tp);
57. //删除工作队列的最后个节点
58. inttp_delete__lastjob(thread_pool*tp);
60. //销毁线程池
61. voidtp_destroy(thread_pool*tp);
63. //消费者线程函数
64. void*tp_thread_func(thread_pool*tp);
66. //生产者线程执行函数
67. void*thread_func_producer(thread_pool*tp);
69. #endif

thread_pool_pv.c：

[cpp] view plain copy print ?

1. //线程池编程实现
2. #include"thread_pool.h"
4. //互斥量,用于对工作队列的访问
5. pthread_mutex_tmutex=PTHREAD_MUTEX_INITIALIZER;
7. //标记线程池是否处于可用状态
8. staticinttp_alive=1;
10. //初始化线程池
11. thread_pool*tp_init(intthread_num){
12. thread_pool*tp;
13. inti;
15. if(thread_num<1)
16. thread_num=1;
18. tp=(thread_pool*)malloc(sizeof(thread_pool));
19. //判断内存分配是否成功
20. if(NULL==tp){
21. printf("ERROR:allocatememoryforthread_poolfailed\n");
22. returnNULL;
23. }
24. tp->threads_num=thread_num;
25. //分配线程所占内存空间
26. tp->threads=(pthread_t*)malloc(thread_num*sizeof(pthread_t));
27. //判断内存分配是否成功
28. if(NULL==tp->threads){
29. printf("ERROR:allocatememoryforthreadsinthreadpoolfailed\n");
30. returnNULL;
31. }
33. if(tp_job_quene_init(tp))
34. returnNULL;
36. tp->job_queue->quene_sem=(sem_t*)malloc(sizeof(sem_t));
37. sem_init(tp->job_queue->quene_sem,0,0);//信号量初始化
39. //初始化线程
40. for(i=0;i<thread_num;++i){
41. pthread_create(&(tp->threads[i]),NULL,(void*)tp_thread_func,(void*)tp);
42. }
44. returntp;
45. }
47. //初始化工作队列
48. inttp_job_quene_init(thread_pool*tp){
49. tp->job_queue=(thread_pool_job_queue*)malloc(sizeof(thread_pool_job_queue));
51. if(NULL==tp->job_queue){
52. return-1;
53. }
55. tp->job_queue->head=NULL;
56. tp->job_queue->tail=NULL;
57. tp->job_queue->num=0;
59. return0;
60. }
62. //线程函数
63. void*tp_thread_func(thread_pool*tp){
64. FUNCfunction;
65. void*arg_buf;
66. thread_pool_job*job_p;
68. while(tp_alive){
69. //线程阻塞,等待信号量
70. if(sem_wait(tp->job_queue->quene_sem)){
71. printf("threadwaitingforsemaphore....\n");
72. exit(1);
73. }
74. if(tp_alive){
75. pthread_mutex_lock(&mutex);
76. job_p=tp_get_lastjob(tp);
77. if(NULL==job_p){
78. pthread_mutex_unlock(&mutex);
79. continue;
80. }
81. function=job_p->function;
82. arg_buf=job_p->arg;
83. if(tp_delete__lastjob(tp))
84. return;
85. pthread_mutex_unlock(&mutex);
86. //运行指定的线程函数
87. printf("consumer...getajobfromjobqueneandrunit!\n");
88. function(arg_buf);
89. free(job_p);
90. }
91. else
92. return;
93. }
95. return;
96. }
98. //向工作队列中添加一个元素
99. voidtp_job_quene_add(thread_pool*tp,thread_pool_job*new_job){
100. new_job->pre=NULL;
101. new_job->next=NULL;
102. thread_pool_job*old_head_job=tp->job_queue->head;
104. if(NULL==old_head_job){
105. tp->job_queue->head=new_job;
106. tp->job_queue->tail=new_job;
107. }
108. else{
109. old_head_job->pre=new_job;
110. new_job->next=old_head_job;
111. tp->job_queue->head=new_job;
112. }
114. ++(tp->job_queue->num);
116. sem_post(tp->job_queue->quene_sem);
117. }
119. //取得工作队列的最后一个节点
120. thread_pool_job*tp_get_lastjob(thread_pool*tp){
121. returntp->job_queue->tail;
122. }
124. //删除工作队列的最后个节点
125. inttp_delete__lastjob(thread_pool*tp){
126. if(NULL==tp)
127. return-1;
129. thread_pool_job*last_job=tp->job_queue->tail;
130. if(0==tp->job_queue->num){
131. return-1;
132. }
133. elseif(1==tp->job_queue->num){
134. tp->job_queue->head=NULL;
135. tp->job_queue->tail=NULL;
136. }
137. else{
138. last_job->pre->next=NULL;
139. tp->job_queue->tail=last_job->pre;
140. }
142. //修改相关变量
143. --(tp->job_queue->num);
145. return0;
146. }
148. //向线程池中添加一个工作项
149. inttp_add_work(thread_pool*tp,void*(*func_p)(void*),void*arg){
150. thread_pool_job*new_job=(thread_pool_job*)malloc(sizeof(thread_pool_job));
151. if(NULL==new_job){
152. printf("ERROR:allocatememoryfornewjobfailed!\n");
153. exit(1);
154. }
155. new_job->function=func_p;
156. new_job->arg=arg;
157. pthread_mutex_lock(&mutex);
158. tp_job_quene_add(tp,new_job);
159. pthread_mutex_unlock(&mutex);
160. }
163. //销毁线程池
164. voidtp_destroy(thread_pool*tp){
165. inti;
166. tp_alive=0;
168. //等待线程运行结束
169. //sleep(10);
170. for(i=0;i<tp->threads_num;++i){
171. pthread_join(tp->threads[i],NULL);
172. }
173. free(tp->threads);
175. if(sem_destroy(tp->job_queue->quene_sem)){
176. printf("ERROR:destroysemaphorefailed!\n");
177. }
178. free(tp->job_queue->quene_sem);
180. //删除ｊｏｂ队列
181. thread_pool_job*current_job=tp->job_queue->tail;
182. while(tp->job_queue->num){
183. tp->job_queue->tail=current_job->pre;
184. free(current_job);
185. current_job=tp->job_queue->tail;
186. --(tp->job_queue->num);
187. }
188. tp->job_queue->head=NULL;
189. tp->job_queue->tail=NULL;
190. }
192. //自定义线程执行函数
193. void*thread_func1(){
194. printf("Task1running...byThread:%u\n",(unsignedint)pthread_self());
195. }
197. //自定义线程执行函数
198. void*thread_func2(){
199. printf("Task2running...byThread:%u\n",(unsignedint)pthread_self());
200. }
202. //生产者线程执行函数
203. void*thread_func_producer(thread_pool*tp){
204. while(1){
205. printf("producer...addajob(job1)tojobquene!\n");
206. tp_add_work(tp,(void*)thread_func1,NULL);
207. sleep(1);
208. printf("producer...addajob(job2)tojobquene!\n");
209. tp_add_work(tp,(void*)thread_func2,NULL);
210. }
211. }
213. intmain(){
214. thread_pool*tp=tp_init(5);
215. inti;
216. intarg=7;
217. pthread_tproducer_thread_id;//生产者线程ID
218. pthread_create(&producer_thread_id,NULL,(void*)thread_func_producer,(void*)tp);
220. pthread_join(producer_thread_id,NULL);
221. tp_destroy(tp);
223. return0;
224. }

运行结果：