线程池的原理和实现

「爱情、让人受尽委屈。」 2022-08-14 01:58 147阅读 0赞

线程池的原理和实现

**一。线程池的简介**

通常我们使用多线程的方式是，需要时创建一个新的线程，在这个线程里执行特定的任务，然后在任务完成后退出。这在一般的应用里已经能够满足我们应用的需求，毕竟我们并不是什么时候都需要创建大量的线程，并在它们执行一个简单的任务后销毁。

但是在一些web、email、database等应用里，比如彩铃，我们的应用在任何时候都要准备应对数目巨大的连接请求，同时，这些请求所要完成的任务却又可能非常的简单，即只占用很少的处理时间。这时，我们的应用有可能处于不停的创建线程并销毁线程的状态。虽说比起进程的创建，线程的创建时间已经大大缩短，但是如果需要频繁的创建线程，并且每个线程所占用的处理时间又非常简短，则线程创建和销毁带给处理器的额外负担也是很可观的。

线程池的作用正是在这种情况下有效的降低频繁创建销毁线程所带来的额外开销。一般来说，线程池都是采用预创建的技术，在应用启动之初便预先创建一定数目的线程。应用在运行的过程中，需要时可以从这些线程所组成的线程池里申请分配一个空闲的线程，来执行一定的任务，任务完成后，并不是将线程销毁，而是将它返还给线程池，由线程池自行管理。如果线程池中预先分配的线程已经全部分配完毕，但此时又有新的任务请求，则线程池会动态的创建新的线程去适应这个请求。当然，有可能，某些时段应用并不需要执行很多的任务，导致了线程池中的线程大多处于空闲的状态，为了节省系统资源，线程池就需要动态的销毁其中的一部分空闲线程。因此，线程池都需要一个管理者，按照一定的要求去动态的维护其中线程的数目。

基于上面的技术，线程池将频繁创建和销毁线程所带来的开销分摊到了每个具体执行的任务上，执行的次数越多，则分摊到每个任务上的开销就越小。

当然，如果线程创建销毁所带来的开销与线程执行任务的开销相比微不足道，可以忽略不计，则线程池并没有使用的必要。比如，FTP、Telnet等应用时。

**二。线程池的设计**

下面利用C语言来实现一个简单的线程池，为了使得这个线程池库使用起来更加方便，特在C实现中加入了一些OO的思想，与Objective-C不同，它仅仅是使用了struct来模拟了c++中的类，其实这种方式在linux内核中大量可见。

在这个库里，与用户有关的接口主要有：

typedef结构tp\_work\_desc\_s tp\_work\_desc; //应用线程执行任务时所需要的一些信息

typedef结构tp\_work\_s tp\_work; //线程执行的任务

typedef结构tp\_thread\_info\_s tp\_thread\_info; //描述了各个线程ID，是否空闲，执行的任务等信息

typedef结构tp\_thread\_pool\_s tp\_thread\_pool; //有关线程池操作的接口信息

//线程的parm

结构tp\_work\_desc\_s \{

......

\};

//基地线程结构

结构tp\_work\_s \{

//主过程中的作用。用户界面

无效（\* process\_job）（tp\_work \*此，tp\_work\_desc \*工作）;

\};

tp\_thread\_pool \* creat\_thread\_pool（INT MIN\_NUM，诠释MAX\_NUM）;

tp\_work\_desc\_s表示应用线程执行任务时所需要的一些信息，会被当作线程的参数传递给每个线程，依据应用的不同而不同，需要用户定义结构的内容。tp\_work\_s就是我们希望线程执行的任务了。当我们申请分配一个新的线程时，首先要明确的指定这两个结构，即该线程完成什么任务，并且完成这个任务需要哪些额外的信息。接口函数creat\_thread\_pool用来创建一个线程池的实例，使用时需要指定该线程池实例所能容纳的最小线程数min\_num和最大线程数max\_num。最小线程数即线程池创建时预创建的线程数目，这个数目的大小也直接影响了线程池所能起到的效果，如果指定的太小，线程池中预创建的线程很快就将分配完毕并需要创建新的线程来适应不断的请求，如果指定的太大，则将可能会有大量的空闲线程。我们需要根据自己应用的实际需要进行指定。描述线程池的结构如下：

//主线程池的结构

结构tp\_thread\_pool\_s \{

TPBOOL（\* INIT）（tp\_thread\_pool \*本）;

无效（\*关）（tp\_thread\_pool \*本）;

无效（\* process\_job）（tp\_thread\_pool \*此，tp\_work \*工人，tp\_work\_desc \*工作）;

INT（\* get\_thread\_by\_id）（tp\_thread\_pool \*此，INT ID）;

TPBOOL（\* add\_thread）（tp\_thread\_pool \*本）;

TPBOOL（\* delete\_thread）（tp\_thread\_pool \*本）;

INT（\* get\_tp\_status）（tp\_thread\_pool \*本）;

INT min\_th\_num; 在游泳池//分线数

INT cur\_th\_num; //池中当前线程数

INT max\_th\_num; //池中的最大线程数

pthread\_mutex\_t的tp\_lock;

的pthread\_t manage\_thread\_id; //处理线程ID NUM

tp\_thread\_info \*的thread\_info; //工作线程的线程相关信息

\};

结构tp\_thread\_info\_s描述了各个线程id、是否空闲、执行的任务等信息，用户并不需要关心它。

//线程信息

结构tp\_thread\_info\_s \{

的pthread\_t THREAD\_ID; //线程ID NUM

TPBOOL is\_busy; //线程状态：真忙; FLASE闲

pthread\_cond\_t thread\_cond;

pthread\_mutex\_t的thread\_lock;

tp\_work \* th\_work;

tp\_work\_desc \* th\_job;

\};

tp\_thread\_pool\_s结构包含了有关线程池操作的接口和变量。在使用creat\_thread\_pool返回一个线程池实例之后，首先要使用明确使用init接口对它进行初始化。在这个初始化过程中，线程池会预创建指定的最小线程数目的线程，它们都处于阻塞状态，并不损耗CPU，但是会占用一定的内存空间。同时init也会创建一个线程池的管理线程，这个线程会在线程池的运行周期内一直执行，它将定时的查看分析线程池的状态，如果线程池中空闲的线程过多，它会删除部分空闲的线程，当然它并不会使所有线程的数目小于指定的最小线程数。

在已经创建并初始化了线程池之后，我们就可以指定tp\_work\_desc\_s和tp\_work\_s结构，并使用线程池的process\_job接口来执行它们。这些就是我们使用这个线程池时所需要了解的所有东西。如果不再需要线程池，可以使用close接口销毁它。

**三。实现代码**

**线程pool.h（头文件）：**

**\[CPP\]**  [查看普通][Link 1] [复印][Link 1] [打印][Link 1] [？][Link 1]

1.  的\#include <stdio.h中>
2.  的\#include <stdlib.h中>
3.  ＃包括文件<sys / types.h中>
4.  的\#include <pthreads.h中>
5.  的\#include <signal.h中>
6.  
7.  \#ifndef的TPBOOL
8.  **的typedef** **INT**  TPBOOL; 
9.  \#ENDIF
10. 
11. \#ifndef的真
12. 的\#define TRUE 1
13. \#ENDIF
14. 
15. \#ifndef的FALSE
16. 的\#define FALSE 0
17. \#ENDIF
18. 
19. ＃定义BUSY\_THRESHOLD 0.5 //（忙线）/（所有线程的阈值）
20. ＃定义MANAGE\_INTERVAL 5 // TP管理线程休眠间隔
21. 
22. **的typedef** **结构** tp\_work\_desc\_s tp\_work\_desc; 
23. **的typedef** **结构** tp\_work\_s tp\_work; 
24. **的typedef** **结构** tp\_thread\_info\_s tp\_thread\_info; 
25. **的typedef** **结构** tp\_thread\_pool\_s tp\_thread\_pool; 
26. 
27. //线程的parm
28. **结构** tp\_work\_desc\_s \{ 
29. **CHAR**  \* INUM; //在调用
30. **CHAR**  \* onum; //调用出来
31. **INT**  CHNUM; //通道NUM
32. \}; 
33. 
34. //基地线程结构
35. **结构** tp\_work\_s \{ 
36. //主过程中的作用。用户界面
37. **无效** （\* process\_job）（tp\_work \* **此**，tp\_work\_desc \*工作）; 
38. \}; 
39. 
40. //线程信息
41. **结构** tp\_thread\_info\_s \{ 
42.  的pthread\_t THREAD\_ID; //线程ID NUM
43.  TPBOOL is\_busy; //线程状态：真忙; FLASE闲
44.  pthread\_cond\_t thread\_cond; 
45.  pthread\_mutex\_t的thread\_lock; 
46.  tp\_work \* th\_work; 
47.  tp\_work\_desc \* th\_job; 
48. \}; 
49. 
50. //主线程池的结构
51. **结构** tp\_thread\_pool\_s \{ 
52.  TPBOOL（\* INIT）（tp\_thread\_pool \* **本**）; 
53. **无效** （\*关）（tp\_thread\_pool \* **本**）; 
54. **无效** （\* process\_job）（tp\_thread\_pool \* **此**，tp\_work \*工人，tp\_work\_desc \*工作）; 
55. **INT**  （\* get\_thread\_by\_id）（tp\_thread\_pool \* **此**， **INT**  ID）; 
56.  TPBOOL（\* add\_thread）（tp\_thread\_pool \* **本**）; 
57.  TPBOOL（\* delete\_thread）（tp\_thread\_pool \* **本**）; 
58. **INT**  （\* get\_tp\_status）（tp\_thread\_pool \* **本**）; 
59. 
60. **INT**  min\_th\_num; //最小线程池中的数量
61. **INT**  cur\_th\_num; 在游泳池//当前线程数
62. **INT**  max\_th\_num; 在游泳池//最大线程数
63.  pthread\_mutex\_t的tp\_lock; 
64.  的pthread\_t manage\_thread\_id; //处理线程ID NUM
65.  tp\_thread\_info \*的thread\_info; //工作线程的线程相关信息
66. \}; 
67. 
68. tp\_thread\_pool \* creat\_thread\_pool（**INT**  MIN\_NUM， **INT**  MAX\_NUM）;

线程pool.c（实现文件）：

**\[CPP\]**  [查看普通][Link 1] [复印][Link 1] [打印][Link 1] [？][Link 1]

1.  ＃包括“线程pool.h”
2.  
3.  **静态****无效** \* tp\_work\_thread（**无效** \*的pthread）; 
4.  **静态****无效** \* tp\_manage\_thread（**无效** \*的pthread）; 
5.  
6.  **静态** TPBOOL tp\_init（tp\_thread\_pool \* **本**）; 
7.  **静态****无效** tp\_close（tp\_thread\_pool \* **本**）; 
8.  **静态****无效** tp\_process\_job（tp\_thread\_pool \* **此**，tp\_work \*工人，tp\_work\_desc \*工作）; 
9.  **静态****INT**  tp\_get\_thread\_by\_id（tp\_thread\_pool \* **此**， **INT**  ID）; 
10. **静态** TPBOOL tp\_add\_thread（tp\_thread\_pool \* **本**）; 
11. **静态** TPBOOL tp\_delete\_thread（tp\_thread\_pool \* **本**）; 
12. **静态****INT**  tp\_get\_tp\_status（tp\_thread\_pool \* **本**）; 
13. 
14. / \*\*
15.  \*用户界面。科瑞线程池。
16.  \*对：
17.  \*民：分线数在池中创建
18.  \*回报：
19.  \*线程池结构实例创建成功
20.  \* /
21. tp\_thread\_pool \* creat\_thread\_pool（**INT**  MIN\_NUM， **INT**  MAX\_NUM）\{ 
22.  tp\_thread\_pool \* **本**; 
23. **该** =（tp\_thread\_pool \*）的malloc（**sizeof运算**（tp\_thread\_pool））; 
24. 
25.  memset的（**这个**，0， **sizeof运算**（tp\_thread\_pool））; 
26. 
27. //初始化成员函数ponter
28. **这**\- >的init = tp\_init; 
29. **这**\- >关闭= tp\_close; 
30. **这**\- > process\_job = tp\_process\_job; 
31. **这**\- > get\_thread\_by\_id = tp\_get\_thread\_by\_id; 
32. **这**\- > add\_thread = tp\_add\_thread; 
33. **这**\- > delete\_thread = tp\_delete\_thread; 
34. **这**\- > get\_tp\_status = tp\_get\_tp\_status; 
35. 
36. //初始化成员变种
37. **这**\- > min\_th\_num = MIN\_NUM; 
38. **这**\- > cur\_th\_num = **本**\- > min\_th\_num; 
39. **这**\- > max\_th\_num = MAX\_NUM; 
40.  pthread\_mutex\_init（**本**\- > tp\_lock，NULL）; 
41. 
42. // malloc的纪念品货号线程信息结构
43. **如果**（NULL =！ **这**\- >的thread\_info） 
44.  免费（**本**\- >的thread\_info）; 
45. **这**\- >的thread\_info =（tp\_thread\_info \*）的malloc（**sizeof运算**（tp\_thread\_info）\* **本**\- > max\_th\_num）; 
46. 
47. **返回****此**; 
48. \} 
49. 
50. 
51. / \*\*
52.  \*成员函数的现实。线程池的初始化函数。
53.  \*对：
54.  \*这样的：线程池结构实例ponter
55.  \*回报：
56.  \*真：成功; 假：失败
57.  \* /
58. TPBOOL tp\_init（tp\_thread\_pool \* **本**）\{ 
59. **诠释** 我; 
60. **INT**  ERR; 
61. 
62. //科瑞工作线程并初始化工作线程信息
63. **对于**（i = 0;我< **本**\- > min\_th\_num;我++）\{ 
64.  pthread\_cond\_init（**这**\- >的thread\_info \[i\]于.thread\_cond，NULL）; 
65.  pthread\_mutex\_init（＆**本**\- >的thread\_info \[i\]于.thread\_lock，NULL）; 
66. 
67.  ERR =的pthread\_create（**本**\- >的thread\_info \[I\] .thread\_id，NULL，tp\_work\_thread， **此**）; 
68. **如果**（0！= ERR）\{ 
69.  的printf（“tp\_init：科瑞工作线程失败\\ N” ）; 
70. **返回** FALSE; 
71.  \} 
72.  的printf（“tp\_init：科瑞工作线程％D \\ N” ， **这**\- >的thread\_info \[I\] .thread\_id）; 
73.  \} 
74. 
75. //科瑞管理线程
76.  ERR =的pthread\_create（**本**\- > manage\_thread\_id，NULL，tp\_manage\_thread， **此**）; 
77. **如果**（0！= ERR）\{ 
78.  的printf（“tp\_init：科瑞管理线程失败\\ N” ）; 
79. **返回** FALSE; 
80.  \} 
81.  的printf（“tp\_init：科瑞管理线程％D \\ N” ， **这**\- > manage\_thread\_id）; 
82. 
83. **返回** TRUE; 
84. \} 
85. 
86. / \*\*
87.  \*成员函数的现实。线程池完全关闭功能。
88.  \*对：
89.  \*这样的：线程池结构实例ponter
90.  \*回报：
91.  \* /
92. **无效** tp\_close（tp\_thread\_pool \* **本**）\{ 
93. **诠释** 我; 
94. 
95. //关闭工作线程
96. **对于**（i = 0; I < **本**\- > cur\_th\_num;我++）\{ 
97.  杀了（**这个**\- >的thread\_info \[I\] .thread\_id，SIGKILL）; 
98.  pthread\_mutex\_destroy（**本**\- >的thread\_info \[I\] .thread\_lock）; 
99.  pthread\_cond\_destroy（**本**\- >的thread\_info \[I\] .thread\_cond）; 
100.  的printf（“tp\_close：杀工作线程％D \\ N” ， **这**\- >的thread\_info \[I\] .thread\_id）; 
101.  \} 
102. 
103. //关闭线程管理
104.  杀了（**这个**\- > manage\_thread\_id，SIGKILL）; 
105.  pthread\_mutex\_destroy（**本**\- > tp\_lock）; 
106.  的printf（“tp\_close：杀了管理线程％D \\ N” ， **这**\- > manage\_thread\_id）; 
107. 
108. //空闲线程结构
109.  免费（**本**\- >的thread\_info）; 
110. \} 
111. 
112. / \*\*
113.  \*成员函数的现实。主界面打开。 
114.  \*让自己的工作和工作后，用户可以使用该功能来处理任务。
115.  \*对：
116.  \*这样的：线程池结构实例ponter
117.  \*工作人员：用户任务的现实。
118.  \*工作：用户对任务
119.  \*回报：
120.  \* /
121. **无效** tp\_process\_job（tp\_thread\_pool \* **此**，tp\_work \*工人，tp\_work\_desc \*作业）\{ 
122. **诠释** 我; 
123. **INT**  tmpid; 
124. 
125. //填补这个 - >的thread\_info的相关工作重点
126. **对于**（i = 0; I < **本**\- > cur\_th\_num;我++）\{ 
127.  调用pthread\_mutex\_lock（**本**\- >的thread\_info \[I\] .thread\_lock）; 
128. **如果**（！**这**\- >的thread\_info \[I\] .is\_busy）\{ 
129.  的printf（“tp\_process\_job：％D线空闲，线程ID为％d \\ N” ，我， **这**\- >的thread\_info \[I\] .thread\_id）; 
130. //线程状态设置忙碌的工作之前，
131. **这**\- >的thread\_info \[I\] .is\_busy = TRUE; 
132.  调用pthread\_mutex\_unlock（**本**\- >的thread\_info \[I\] .thread\_lock）; 
133. 
134. **这**\- >的thread\_info \[I\] .th\_work =工作者; 
135. **这**\- >的thread\_info \[I\] .th\_job =工作; 
136. 
137.  的printf（“tp\_process\_job：通知空闲的工作线程％D，线程ID为％d \\ N” ，我， **这**\- >的thread\_info \[I\] .thread\_id）; 
138.  调用pthread\_cond\_signal（**本**\- >的thread\_info \[I\] .thread\_cond）; 
139. 
140. **返回**; 
141.  \} 
142. **其他**
143.  调用pthread\_mutex\_unlock（**本**\- >的thread\_info \[I\] .thread\_lock）; 
144.  \} 的//结束
145. 
146. //如果目前所有的线程都很忙，新的线程被创建在这里
147.  调用pthread\_mutex\_lock（**本**\- > tp\_lock）; 
148. **如果**（ **本**\- > add\_thread（**本**））\{ 
149.  I = **这个**\- > cur\_th\_num - 1; 
150.  tmpid = **本**\- >的thread\_info \[I\] .thread\_id; 
151. **这**\- >的thread\_info \[I\] .th\_work =工作者; 
152. **这**\- >的thread\_info \[I\] .th\_job =工作; 
153.  \} 
154.  调用pthread\_mutex\_unlock（**本**\- > tp\_lock）; 
155. 
156. //发送COND工作线程
157.  的printf（“tp\_process\_job：通知空闲的工作线程％D，线程ID为％d \\ N” ，我， **这**\- >的thread\_info \[I\] .thread\_id）; 
158.  调用pthread\_cond\_signal（**本**\- >的thread\_info \[I\] .thread\_cond）; 
159. **返回**; 
160. \} 
161. 
162. / \*\*
163.  \*成员函数的现实。获得通过线程ID NUM真正的线程。
164.  \*对：
165.  \*这样的：线程池结构实例ponter
166.  \* ID：线程ID NUM
167.  \*回报：
168.  \*在线程信息结构体数组序列NUM
169.  \* /
170. **INT**  tp\_get\_thread\_by\_id（tp\_thread\_pool \* **此**， **INT**  ID）\{ 
171. **诠释** 我; 
172. 
173. **对于**（i = 0; I < **本**\- > cur\_th\_num;我++）\{ 
174. **如果**（ID == **本**\- >的thread\_info \[I\] .thread\_id） 
175. **回报** 我; 
176.  \} 
177. 
178. **返回** \-1; 
179. \} 
180. 
181. / \*\*
182.  \*成员函数的现实。添加新线程入池。
183.  \*对：
184.  \*这样的：线程池结构实例ponter
185.  \*回报：
186.  \*真：成功; 假：失败
187.  \* /
188. **静态** TPBOOL tp\_add\_thread（tp\_thread\_pool \* **本**）\{ 
189. **INT**  ERR; 
190.  tp\_thread\_info \* new\_thread; 
191. 
192. **如果**（ **本**\- > max\_th\_num <= **这个**\- > cur\_th\_num） 
193. **返回** FALSE; 
194. 
195. // malloc的新的线程信息结构
196.  new\_thread = **本**\- >的thread\_info \[ **本**\- > cur\_th\_num\] 
197. 
198. //初始化新线程的COND与互斥
199.  pthread\_cond\_init（new\_thread-> thread\_cond，NULL）; 
200.  pthread\_mutex\_init（new\_thread-> thread\_lock，NULL）; 
201. 
202. //初始化状态为忙
203.  new\_thread-> is\_busy = TRUE; 
204. 
205. //在池中添加当前线程数。
206. **这**\- > cur\_th\_num ++; 
207. 
208.  ERR =的pthread\_create（new\_thread->的thread\_id，NULL，tp\_work\_thread， **此**）; 
209. **如果**（0！= ERR）\{ 
210.  免费（new\_thread）; 
211. **返回** FALSE; 
212.  \} 
213.  的printf（“tp\_add\_thread：科瑞工作线程％D \\ N” ， **这**\- >的thread\_info \[ **本**\- > cur\_th\_num-1\] .thread\_id）; 
214. 
215. **返回** TRUE; 
216. \} 
217. 
218. / \*\*
219.  \*成员函数的现实。删除空闲线程池中。
220.  \*只删除最后一个空闲线程池中。
221.  \*对：
222.  \*这样的：线程池结构实例ponter
223.  \*回报：
224.  \*真：成功; 假：失败
225.  \* /
226. **静态** TPBOOL tp\_delete\_thread（tp\_thread\_pool \* **本**）\{ 
227. //当前线程NUM不能<分钟线NUM
228. **如果**（**本**\- > cur\_th\_num <= **这个**\- > min\_th\_num） **返回** FALSE; 
229. 
230. //如果最后一个线程是忙，什么也不做
231. **如果**（**本**\- >的thread\_info \[ **本**\- > cur\_th\_num-1\] .is\_busy） **返回** FALSE; 
232. 
233. //杀空闲线程和免费信息结构
234.  杀了（**这个**\- >的thread\_info \[ **本**\- > cur\_th\_num-1\] .thread\_id，SIGKILL）; 
235.  pthread\_mutex\_destroy（**本**\- >的thread\_info \[ **本**\- > cur\_th\_num-1\] .thread\_lock）; 
236.  pthread\_cond\_destroy（**本**\- >的thread\_info \[ **本**\- > cur\_th\_num-1\] .thread\_cond）; 
237. 
238. //删除空闲线程后，当前线程NUM -1
239. **这**\- > cur\_th\_num--; 
240. 
241. **返回** TRUE; 
242. \} 
243. 
244. / \*\*
245.  \*成员函数的现实。获取当前线程池的状态：空闲的，正常的，忙碌的，.etc。
246.  \*对：
247.  \*这样的：线程池结构实例ponter
248.  \*回报：
249.  \* 0：空闲; 1：正常或占线（不处理）
250.  \* /
251. **静态****INT**  tp\_get\_tp\_status（tp\_thread\_pool \* **本**）\{ 
252. **浮** busy\_num = 0.0; 
253. **诠释** 我; 
254. 
255. //忙碌的线程数
256. **对于**（i = 0; I < **本**\- > cur\_th\_num;我++）\{ 
257. **如果**（**本**\- >的thread\_info \[I\] .is\_busy） 
258.  busy\_num ++; 
259.  \} 
260. 
261. //0.2？或其他NUM？
262. **如果**（busy\_num /（**本**\- > cur\_th\_num）<BUSY\_THRESHOLD） 
263. **返回** 0; //空闲状态
264. **其他**
265. **返回** 1; //忙或正常状态 
266. \} 
267. 
268. / \*\*
269.  \*内部接口。真正的工作线程。
270.  \*对：
271.  \* pthread的：线程池结构ponter
272.  \*回报：
273.  \* /
274. **静态****无效** \* tp\_work\_thread（**无效** \*的pthread）\{ 
275.  的pthread\_t curid; //当前线程的id
276. **INT**  NSEQ; //在这- >的thread\_info数组当前线程的序列
277.  tp\_thread\_pool \* **本** =（tp\_thread\_pool \*）的pthread; //主线程池的结构实例
278. 
279. //获取当前线程的id
280.  curid = pthread\_self（）; 
281. 
282. //获取线程信息结构体数组中当前线程的序列。
283.  NSEQ = **本**\- > get\_thread\_by\_id（**本**，curid）; 
284. **如果**（NSEQ <0） 
285. **返回**; 
286.  的printf（ “ 进入工作线程％D，线程ID为％d \\ N” ，NSEQ，curid）; 
287. 
288. //等待COND处理真正的工作。
289. **而**（TRUE）\{ 
290.  调用pthread\_mutex\_lock（**本**\- >的thread\_info \[NSEQ\] .thread\_lock）; 
291.  调用pthread\_cond\_wait（**本**\- >的thread\_info \[NSEQ\] .thread\_cond，与**此**\- >的thread\_info \[NSEQ\] .thread\_lock）; 
292.  调用pthread\_mutex\_unlock（**本**\- >的thread\_info \[NSEQ\] .thread\_lock）; 
293. 
294.  的printf（ “％d 个线程做的工作\\ñ！” ，pthread\_self（））; 
295. 
296.  tp\_work \* =工作 **这个**\- >的thread\_info \[NSEQ\] .th\_work; 
297.  tp\_work\_desc \* =作业 **本**\- >的thread\_info \[NSEQ\] .th\_job; 
298. 
299. //过程
300.  与工作> process\_job（工作职位）; 
301. 
302. //线程状态设置下班后的空闲
303.  调用pthread\_mutex\_lock（**本**\- >的thread\_info \[NSEQ\] .thread\_lock）; 
304. **这**\- >的thread\_info \[NSEQ\] .is\_busy = FALSE; 
305.  调用pthread\_mutex\_unlock（**本**\- >的thread\_info \[NSEQ\] .thread\_lock）; 
306. 
307.  的printf（ “％d 执行工作在\\ N” ，pthread\_self（））; 
308.  \} 
309. \} 
310. 
311. / \*\*
312.  \*内部接口。管理线程池来删除空闲线程。
313.  \*对：
314.  \* pthread的：线程池结构ponter
315.  \*回报：
316.  \* /
317. **静态****无效** \* tp\_manage\_thread（**无效** \*的pthread）\{ 
318.  tp\_thread\_pool \* **本** =（tp\_thread\_pool \*）的pthread; //主线程池的结构实例
319. 
320. // 1？
321.  睡眠（MANAGE\_INTERVAL）; 
322. 
323. **做**\{ 
324. **如果**（ **本**\- > get\_tp\_status（**本**）== 0）\{ 
325. **做**\{ 
326. **如果**（！**这**\- > delete\_thread（**本**）） 
327. **打破**; 
328.  \} **而**（TRUE）; 
329.  \} //结束，如果
330. 
331. // 1？
332.  睡眠（MANAGE\_INTERVAL）; 
333.  \} **而**（TRUE）; 
334. \}

**四。数据库连接池介绍**

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。

性能低下。

连接池技术尽可能多地重用了消耗内存地资源，大大节省了内存，提高了服务器地服务效率，能够支持更多的客户服务。通过使用连接池，将大大提高程序运行效率，同时，我们可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。

1）最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；  
2)最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。

**参考资料：**

1. libthreadpool库的实现：

2。 [http://www.cnblogs.com/cute/archive/2012/09/18/2690616.html][http_www.cnblogs.com_cute_archive_2012_09_18_2690616.html]

3.“线程池技术在并发服务器中的应用” - 计算机与数字工程

[Link 1]: http://blog.csdn.net/chdhust/article/details/8753923#
[http_www.cnblogs.com_cute_archive_2012_09_18_2690616.html]: http://www.cnblogs.com/cute/archive/2012/09/18/2690616.html