Linux 下C语言简单实现线程池

C语言简单实现线程池

0前言

网上关于线程池的例子还是不少，简单明了的倒是比较少，看了网上的资料，打算借鉴网上的一些例子，自己实现以下。

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

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

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

1线程池优点

下面使用网上资源验证线程池如何提高服务器性能的。

我所提到服务器程序是指能够接受客户请求并能处理请求的程序，而不只是指那些接受网络客户请求的网络服务器程序。

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。但如果对多线程应用不当，会增加对单个任务的处理时间。可以举一个简单的例子：

假设在一台服务器完成一项任务的时间为T

T1 创建线程的时间

T2 在线程中执行任务的时间，包括线程间同步所需时间

T3 线程销毁的时间

显然T ＝ T1＋T2＋T3。注意这是一个极度简化的假设。

可以看出T1,T3是多线程本身的带来的开销，我们渴望减少T1,T3所用的时间，从而减少T的时间。但一些线程的使用者并没有注意到这一点，所以在程序中频繁的创建或销毁线程，这导致T1和T3在T中占有相当比例。显然这是突出了线程的弱点（T1，T3），而不是优点（并发性）。

线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目。在看一个例子：

假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。我们比较利用线程池技术和不利于线程池技术的服务器处理这些请求时所产生的线程总数。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目或者上限（以下简称线程池尺寸），而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池尺寸是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

这些都是假设，不能充分说明问题，下面我将讨论线程池的简单实现并对该程序进行对比测试，以说明线程技术优点及应用领域。

2线程池的简单实现

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

1. 线程池管理器（ThreadPoolManager）:用于创建并管理线程池
2. 工作线程（WorkThread）: 线程池中线程
3. 任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。
4. 任务队列:用于存放没有处理的任务。提供一种缓冲机制。

下面是代码：

全局文件：

[cpp] view plain copy

1. /**********************************
2. *@author<ahref="mailto:wallwind@yeah.net">wallwind@<spanstyle="color:#000000;">yeah.net</span></a>
3. *@date2012/06/13
4. *Lastupdate:2012/06/13
5. *License:LGPL
6. *
7. **********************************/
9. #ifndef_GLOBAL_H_
10. #define_GLOBAL_H_
12. #include<sys/types.h>
13. #include<sys/time.h>
14. #include<unistd.h>/**/
15. #include<stdarg.h>
16. #include<stddef.h>/*offsetof()*/
17. #include<stdio.h>
18. #include<stdlib.h>
19. #include<errno.h>
20. #include<string.h>
21. #include<signal.h>
22. #include<pwd.h>
23. #include<grp.h>
24. #include<dirent.h>
25. #include<glob.h>
26. #include<sys/vfs.h>/*statfs()*/
28. #include<sys/uio.h>
29. #include<sys/stat.h>
30. #include<fcntl.h>
32. #include<sys/wait.h>
33. #include<sys/mman.h>
34. #include<sys/resource.h>
35. #include<sched.h>
37. #include<sys/socket.h>
38. #include<netinet/in.h>
39. #include<netinet/tcp.h>/*TCP_NODELAY,TCP_CORK*/
40. #include<arpa/inet.h>
41. #include<netdb.h>
42. #include<sys/un.h>
44. #include<time.h>/*tzset()*/
45. #include<malloc.h>/*memalign()*/
46. #include<limits.h>/*IOV_MAX*/
47. #include<sys/ioctl.h>
48. #include<sys/sysctl.h>
49. #include<crypt.h>
50. #include<sys/utsname.h>/*uname()*/
51. #include<semaphore.h>
53. #include<sys/epoll.h>
54. #include<poll.h>
55. #include<sys/syscall.h>
56. #include<pthread.h>
57. #endif

thread.c文件

[cpp] view plain copy

1. /**********************************
2. *@authorwallwind@yeah.net
3. *@date2012/06/13
4. *Lastupdate:2012/06/13
5. *License:LGPL
6. *
7. **********************************/
11. #ifndef_THPOOL_
12. #define_THPOOL_
14. #include"global.h"
15. /**
16. 定义一个任务节点
17. **/
18. typedefvoid*(*FUNC)(void*arg);
21. typedefstruct_thpool_job_t{
22. //void*(*function)(void*arg);//函数指针
23. FUNCfunction;
24. void*arg;//函数参数。
25. struct_thpool_job_t*prev;//指向上一个节点
26. struct_thpool_job_t*next;//指向下一个节点
27. }thpool_job_t;
29. /**
30. 定义一个工作队列
31. **/
33. typedefstruct_thpool_job_queue{
34. thpool_job_t*head;//队列头指针
35. thpool_job_t*tail;//队列末尾指针
36. intjobN;//任务数
37. sem_t*queueSem;//x信号量
38. }thpool_jobqueue;
40. /**
41. 线程池
42. **/
44. typedefstruct_thpool_t{
45. pthread_t*threads;////线程指针数
46. intthreadsN;////线程数
47. thpool_jobqueue*jobqueue;//指向队列指针
48. }thpool_t;
50. typedefstructthread_data{
51. pthread_mutex_t*mutex_p;
52. thpool_t*tp_p;
53. }thread_data;
55. //初始化线程池内部的线程数
56. thpool_t*thpool_init(intthreadN);
58. voidthpool_thread_do(thpool_t*tp_p);
60. intthpool_add_work(thpool_t*tp_p,void*(*function_p)(void*),void*arg_p);
62. voidthpool_destroy(thpool_t*tp_p);
66. intthpool_jobqueue_init(thpool_t*tp_p);
70. voidthpool_jobqueue_add(thpool_t*tp_p,thpool_job_t*newjob_p);
72. intthpool_jobqueue_removelast(thpool_t*tp_p);
74. thpool_job_t*thpool_jobqueue_peek(thpool_t*tp_p);
76. voidthpool_jobqueue_empty(thpool_t*tp_p);
78. #endif

thread.c

[cpp] view plain copy

1. /**********************************
2. *@authorwallwind@yeah.net
3. *@date2012/06/13
4. *Lastupdate:2012/06/13
5. *License:LGPL
6. *
7. **********************************/
8. #include"global.h"
9. #include"Thread.h"
10. #include<errno.h>
12. staticintthpool_keepalive=1;
14. /*创建互斥量，并初始化*/
15. pthread_mutex_tmutex=PTHREAD_MUTEX_INITIALIZER;/*usedtoserializequeueaccess*/
17. thpool_t*thpool_init(intthreadN)
18. {
19. thpool_t*thpool;
20. if(!threadN||threadN<1)
21. threadN=1;
22. ///分配线程池内存
23. thpool=(thpool_t*)malloc(sizeof(thpool_t));
24. if(thpool==NULL)
25. {
26. printf("mallocthpool_terror");
27. returnNULL;
28. }
29. //分配线程数
30. thpool->threadsN=threadN;
31. thpool->threads=(pthread_t*)malloc(threadN*sizeof(pthread_t));
32. if(thpool->threads==NULL)
33. {
34. printf("mallocthpool->threadserror");
35. returnNULL;
36. }
37. if(thpool_jobqueue_init(thpool))
38. return-1;
40. thpool->jobqueue->queueSem=(sem_t*)malloc(sizeof(sem_t));
41. sem_init(thpool->jobqueue->queueSem,0,1);
42. intt;
43. for(t=0;t<threadN;t++)
44. {
45. pthread_create(&(thpool->threads[t]),NULL,(void*)thpool_thread_do,(void*)thpool);
46. }
48. returnthpool;
49. }
51. voidthpool_destroy(thpool_t*tp_p)
52. {
53. inti;
54. thpool_keepalive=0;
56. for(i=0;i<(tp_p->threadsN);i++)
57. {
58. if(sem_post(tp_p->jobqueue->queueSem))
59. {
60. fprintf(stderr,"thpool_destroy():Couldnotbypasssem_wait()\n");
61. }
63. }
64. if(sem_post(tp_p->jobqueue->queueSem)!=0)
65. {
66. fprintf(stderr,"thpool_destroy():Couldnotdestroysemaphore\n");
67. }
68. for(i=0;i<(tp_p->threadsN);i++)
69. {
70. pthread_join(tp_p->threads[i],NULL);
71. }
72. thpool_jobqueue_empty(tp_p);
74. free(tp_p->threads);
75. free(tp_p->jobqueue->queueSem);
76. free(tp_p->jobqueue);
77. free(tp_p);
79. }
80. ////对双向队列初始化
81. /*Initialisequeue*/
82. intthpool_jobqueue_init(thpool_t*tp_p){
83. tp_p->jobqueue=(thpool_jobqueue*)malloc(sizeof(thpool_jobqueue));/*MALLOCjobqueue*/
84. if(tp_p->jobqueue==NULL)return-1;
85. tp_p->jobqueue->tail=NULL;
86. tp_p->jobqueue->head=NULL;
87. tp_p->jobqueue->jobN=0;
88. return0;
89. }
91. ////
92. voidthpool_thread_do(thpool_t*tp_p)
93. {
94. while(thpool_keepalive==1)
95. {
96. if(sem_wait(tp_p->jobqueue->queueSem))///线程阻塞,等待通知直到消息队列有数据
97. {
98. perror("thpool_thread_do():Waitingforsemaphore");
99. exit(1);
100. }
101. if(thpool_keepalive)
102. {
103. //(void*)(*function)(void*arg);
104. FUNCfunction;
105. void*arg_buff;
106. thpool_job_t*job_p;
108. pthread_mutex_lock(&mutex);
109. job_p=thpool_jobqueue_peek(tp_p);
110. function=job_p->function;
111. arg_buff=job_p->arg;
112. if(thpool_jobqueue_removelast(tp_p))
113. return;
114. pthread_mutex_unlock(&mutex);
115. function(arg_buff);//运行你的方法。
116. free(job_p);////释放掉。
117. }
118. else
119. {
120. return;
121. }
123. }
124. return;
125. }
127. //得到第一个队列的一个节点
128. thpool_job_t*thpool_jobqueue_peek(thpool_t*tp_p)
129. {
130. returntp_p->jobqueue->tail;
131. }
132. /////删除队列的最后一个节点
133. intthpool_jobqueue_removelast(thpool_t*tp_p)
134. {
135. if(tp_p==NULL)
136. return-1;
137. thpool_job_t*theLastJob;
138. theLastJob=tp_p->jobqueue->tail;
139. switch(tp_p->jobqueue->jobN)
140. {
141. case0:
142. return-1;
143. case1:
144. tp_p->jobqueue->head=NULL;
145. tp_p->jobqueue->tail=NULL;
146. break;
147. default:
148. theLastJob->prev->next=NULL;
149. tp_p->jobqueue->tail=theLastJob->prev;
151. }
152. (tp_p->jobqueue->jobN)--;
153. intreval;
154. sem_getvalue(tp_p->jobqueue->queueSem,&reval);
155. return0;
156. }
158. voidthpool_jobqueue_add(thpool_t*tp_p,thpool_job_t*newjob_p)
159. {
160. newjob_p->next=NULL;
161. newjob_p->prev=NULL;
162. thpool_job_t*oldFirstJob;
163. oldFirstJob=tp_p->jobqueue->head;
165. switch(tp_p->jobqueue->jobN)
166. {
167. case0:
168. tp_p->jobqueue->head=newjob_p;
169. tp_p->jobqueue->tail=newjob_p;
170. break;
171. default:
172. oldFirstJob->prev=newjob_p;
173. newjob_p->next=oldFirstJob;
174. tp_p->jobqueue->head=newjob_p;
176. }
177. (tp_p->jobqueue->jobN)++;
178. sem_post(tp_p->jobqueue->queueSem);
180. intreval;
181. sem_getvalue(tp_p->jobqueue->queueSem,&reval);
182. return;
183. }
185. /////将消息加入线程池
186. intthpool_add_work(thpool_t*tp_p,void*(*function_p)(void*),void*arg_p)
187. {
188. thpool_job_t*newjob;
189. newjob=(thpool_job_t*)malloc(sizeof(thpool_job_t));
191. if(newjob==NULL)
192. {
193. fprintf(stderr,"thpool_add_work():Couldnotallocatememoryfornewjob\n");
194. exit(1);
195. }
196. newjob->function=function_p;
197. newjob->arg=arg_p;
198. pthread_mutex_lock(&mutex);
199. thpool_jobqueue_add(tp_p,newjob);
200. pthread_mutex_unlock(&mutex);
201. return0;
202. }
204. ///清空队列
205. voidthpool_jobqueue_empty(thpool_t*tp_p)
206. {
207. thpool_job_t*curjob;
208. curjob=tp_p->jobqueue->tail;
210. while(tp_p->jobqueue->jobN)
211. {
212. tp_p->jobqueue->tail=curjob->prev;
213. free(curjob);
214. curjob=tp_p->jobqueue->tail;
215. (tp_p->jobqueue->jobN)--;
216. }
217. tp_p->jobqueue->head=NULL;
218. tp_p->jobqueue->tail=NULL;
219. }

下面是mian函数文件

[cpp] view plain copy

1. /**********************************
2. *@authorwallwind@yeah.net
3. *@date2012/06/13
4. *Lastupdate:2012/06/13
5. *License:LGPL
6. *
7. **********************************/
9. #include"global.h"
10. #include"Thread.h"
12. void*task1()
13. {
14. printf("#Threadworking:%u\n",(int)pthread_self());
15. printf("Task1running..\n");
16. }
19. /*Somearbitrarytask2*/
20. void*task2(inta)
21. {
22. printf("#Threadworking:%u\n",(int)pthread_self());
23. printf("Task2running..\n");
24. printf("%d\n",a);
25. }
26. intmain()
27. {
28. printf("~~~~~~~~~~~");
29. thpool_t*thpool;
30. inti;
31. thpool=thpool_init(5);
32. puts("Adding20taskstothreadpool");
33. inta=54;
34. for(i=0;i<20;i++){
35. thpool_add_work(thpool,(void*)task1,NULL);
36. thpool_add_work(thpool,(void*)task2,(void*)a);
37. };
40. puts("Willkillthreadpool");
41. thpool_destroy(thpool);
43. }

在linux下写程序少不了makefile文件。于是我自己写了一个比较通用的makefile文件。仅供大家参考

makefile 代码

[cpp] view plain copy

1. SRCS=$(wildcard*.c)
3. OBJS=$(SRCS:.c=.o)
5. CC=gcc
7. INCLUDES=-I/
9. LIBS=-L/-lpthread
11. CCFLAGS=-g-Wall-O0
13. cThreadPool:$(OBJS)
15. $(CC)$^-o$@$(INCLUDES)$(LIBS)
17. %.o:%.cpp
19. $(CC)-c$<$(CCFLAGS)
22. clean:
24. rm*.o
26. .PHONY:clean

运行效果如下图

[cpp] view plain copy

1. ./test
2. Createdthread0inpool
3. Createdthread1inpool
4. Createdthread2inpool
5. Createdthread3inpool
6. Adding20taskstothreadpool
7. #Threadworking:3086773136
8. Task1running..
9. #Threadworking:3076283280
10. Task2running..
11. 54
12. #Threadworking:3086773136
13. Task1running..
14. #Threadworking:3086773136
15. Task2running..
16. 54
17. #Threadworking:3076283280
18. Task1running..
19. #Threadworking:3086773136
20. Task2running..
21. 54
22. #Threadworking:3076283280
23. Task1running..
24. #Threadworking:3086773136
25. Task2running..
26. 54
27. #Threadworking:3076283280
28. Task1running..
29. #Threadworking:3086773136
30. Task2running..
31. 54
32. #Threadworking:3076283280
33. Task1running..
34. #Threadworking:3086773136
35. Task2running..
36. 54
37. #Threadworking:3076283280
38. Task1running..
39. #Threadworking:3086773136
40. Task2running..
41. 54
42. #Threadworking:3076283280
43. Task1running..
44. #Threadworking:3086773136
45. Task2running..
46. 54
47. #Threadworking:3076283280
48. Task1running..
49. #Threadworking:3086773136
50. Task2running..
51. 54
52. #Threadworking:3076283280
53. Task1running..
54. #Threadworking:3086773136
55. Task2running..
56. 54
57. Willkillthreadpool

线程池也是参考了别人的。