池化技术 漫谈

原文地址：http://blog.csdn.net/magictong/article/details/3143947

池化技术 - 简单点来说，就是提前保存大量的资源，以备不时之需，O(∩_∩)O，对于线程，内存，oracle的连接对象等等，这些都是资源，程序中当你创建一个线程或者在堆上申请一块内存时，都涉及到很多系统调用，也是非常消耗CPU的，如果你的程序需要很多类似的工作线程或者需要频繁的申请释放小块内存，如果没有在这方面进行优化，那很有可能这部分代码将会成为影响你整个程序性能的瓶颈。池化技术主要有线程池，内存池，连接池，对象池等等，对象池就是提前创建很多对象，将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来重复使用，连接池比较典型的有oracle的连接池，了解不深。

下面主要谈谈线程池和内存池，因为这两种技术的通用性和实用性也是比较强的，描述语言C++，其实线程池的话用什么实现都可以。

先来谈谈线程池技术，线程池的框架早就有先辈给我们想好了，也就不用我们去冥思苦想了，我们要做的就是把先辈的想法发现即可。

其实线程池的原理很简单，类似于操作系统中的缓冲区的概念，它的流程如下：先启动若干数量的线程，并让这些线程都处于睡眠状态，当客户端有一个新请求时，就会唤醒线程池中的某一个睡眠线程，让它来处理客户端的这个请求，当处理完这个请求后，线程又处于睡眠状态。可能你也许会问：为什么要搞得这么麻烦，如果每当客户端有新的请求时，我就创建一个新的线程不就完了？这也许是个不错的方法，因为它能使得你编写代码相对容易一些，但你却忽略了一个重要的问题？性能！尤其是对于服务器程序尤为重要，服务器程序会先初始化很多线程在那里等待，当有客户连接时，就激活其中的一个线程来处理客户请求，对于不支持动态增加的线程池，如果没有等待线程，客户就必学等待，而对于能动态增加线程的线程池，则可以像线程池中新加一个线程。

下面是一个用c++实现的线程池，支持动态增减线程数量：

1. /*-------------------------------------------------------------------------
2. //文件名：KThreadPool.h
3. //创建者：magicTong
4. //创建时间：2008-10-2315:02:31
5. //功能描述：线程池声明
6. //
7. //$Id:$
8. //-----------------------------------------------------------------------*/
9. #ifndef__KTHREADPOOL_H__
10. #define__KTHREADPOOL_H__
12. //-------------------------------------------------------------------------
14. #include<windows.h>
15. #include<list>
17. usingnamespacestd;
19. //线程函数指针定义
20. typedefDWORD(WINAPI*PTHREAD_FUNC_EX)(LPVOIDlpThreadParameter);
22. //线程状态枚举
23. typedefenum_enumKThreadStatus
24. {
25. THREADRUN,//运行
26. THREADPAUSE,//暂停
27. }
28. KThreadStatus;
30. //-------------------------------------------------------------------------
31. //类名:KThread
32. //功能:线程类，可动态更换执行函数
33. //附注:
34. //-------------------------------------------------------------------------
35. classKThread
36. {
37. public:
38. //构造
39. KThread();
41. //析构
42. ~KThread();
44. //-------------------------------------------------------------------------
45. //函数:Init
46. //功能:初始化函数
47. //返回值:bool
48. //附注:
49. //-------------------------------------------------------------------------
50. boolInit();
52. //-------------------------------------------------------------------------
53. //函数:Run
54. //功能:运行线程
55. //返回值:bool
56. //附注:
57. //-------------------------------------------------------------------------
58. boolRun();
60. //-------------------------------------------------------------------------
61. //函数:Pause
62. //功能:暂停线程
63. //返回值:bool
64. //附注:
65. //-------------------------------------------------------------------------
66. boolPause();
68. //-------------------------------------------------------------------------
69. //函数:Join
70. //功能:调用Join的线程将阻塞，直到该线程执行完毕
71. //返回值:void
72. //附注:
73. //-------------------------------------------------------------------------
74. voidJoin();
76. //-------------------------------------------------------------------------
77. //函数:SetProc
78. //功能:设置线程运行的函数，和要传给线程的参数
79. //返回值:void
80. //参数:PTHREAD_FUNC_EXproc
81. //参数:void*lpParam
82. //附注:
83. //-------------------------------------------------------------------------
84. voidSetProc(PTHREAD_FUNC_EXproc,void*lpParam);
86. protected:
87. KThread(KThread&){}
89. //线程实际运行的函数
90. staticDWORDWINAPIRealThreadProc(void*lpParam);
92. friendclassKThreadPool;
94. protected:
95. structKThreadParam
96. {
97. PTHREAD_FUNC_EXproc;//用户线程函数
98. void*lpParam;//用户线程参数
99. KThread*pThread;//线程类对象
100. };
102. HANDLEm_hThread;
103. DWORDm_id;
104. KThreadParamm_param;
105. KThreadStatusm_status;
107. HANDLEm_hEvt;
108. HANDLEm_hMtx;
109. };
111. //-------------------------------------------------------------------------
112. //类名:KThreadPool
113. //功能:线程池类声明
114. //附注:
115. //-------------------------------------------------------------------------
116. classKThreadPool
117. {
118. public:
120. //构造，initNum初始情况线程数量
121. KThreadPool(intinitNum);
123. //析构
124. ~KThreadPool();
126. //-------------------------------------------------------------------------
127. //函数:DoWork
128. //功能:申请线程进行工作，proc工作函数，lpParam工作函数参数，run是否立即运行，返回线程ID
129. //返回值:DWORD
130. //参数:PTHREAD_FUNC_EXproc
131. //参数:void*lpParam
132. //参数:boolrun=true
133. //附注:
134. //-------------------------------------------------------------------------
135. DWORDDoWork(PTHREAD_FUNC_EXproc,void*lpParam,boolrun=true);
137. //-------------------------------------------------------------------------
138. //函数:Run
139. //功能:运行线程，id线程ID
140. //返回值:bool
141. //参数:DWORDid
142. //附注:
143. //-------------------------------------------------------------------------
144. boolRun(DWORDid);
146. //-------------------------------------------------------------------------
147. //函数:Pause
148. //功能:暂停运行线程，id线程ID
149. //返回值:bool
150. //参数:DWORDid
151. //附注:
152. //-------------------------------------------------------------------------
153. boolPause(DWORDid);
155. //调整线程池大小为size，返回调整后线程池大小
156. unsignedSetSize(unsignedsize);
158. protected:
159. list<KThread*>m_lst;
160. };

实现：

1. /*-------------------------------------------------------------------------
2. //文件名：KThreadPool.cpp
3. //创建者：magicTong
4. //创建时间：2008-10-2315:02:22
5. //功能描述：线程池定义
6. //
7. //$Id:$
8. //-----------------------------------------------------------------------*/
10. #include"stdafx.h"
11. #include"KThreadPool.h"
13. //-------------------------------------------------------------------------
16. //-------------------------------------------------------------------------
17. //KThread类定义开始
18. //-------------------------------------------------------------------------
19. KThread::KThread():m_hThread(NULL),
20. m_status(THREADPAUSE),
21. m_hEvt(0),
22. m_hMtx(0)
23. {
24. }
26. KThread::~KThread()
27. {
28. ::CloseHandle(m_hMtx);
29. if(::TerminateThread(m_hThread,-1)==0)
30. return;
31. }
33. boolKThread::Init()
34. {
35. m_hThread=::CreateThread(
36. 0,
37. 0,
38. (PTHREAD_FUNC_EX)(KThread::RealThreadProc),
39. (void*)&m_param,
40. CREATE_SUSPENDED,
41. &m_id);
43. //创建线程失败
44. if(NULL==m_hThread)
45. {
46. returnfalse;
47. }
48. m_param.proc=NULL;
49. m_param.lpParam=NULL;
50. m_param.pThread=this;
52. //自动复位
53. m_hEvt=::CreateEvent(0,FALSE,FALSE,0);
54. if(m_hEvt==0)
55. {
56. ::CloseHandle(m_hThread);
57. returnfalse;
58. }
60. m_hMtx=::CreateMutex(0,0,0);
61. if(m_hMtx==0)
62. {
63. ::CloseHandle(m_hEvt);
64. ::CloseHandle(m_hThread);
65. returnfalse;
66. }
68. returntrue;
69. }
71. boolKThread::Run()
72. {
73. ::WaitForSingleObject(m_hMtx,INFINITE);
74. if(m_status==THREADPAUSE)
75. if(::ResumeThread(m_hThread)==-1)
76. {
77. ::ReleaseMutex(m_hMtx);
78. returnfalse;
79. }
81. m_status=THREADRUN;
82. ::ReleaseMutex(m_hMtx);
83. returntrue;
84. }
86. boolKThread::Pause()
87. {
88. ::WaitForSingleObject(m_hMtx,INFINITE);
89. if(m_status==THREADRUN)
90. if(::SuspendThread(m_hThread)==-1)
91. {
92. ::ReleaseMutex(m_hMtx);
93. returnfalse;
94. }
96. m_status=THREADPAUSE;
97. ::ReleaseMutex(m_hMtx);
98. returntrue;
99. }
101. voidKThread::Join()
102. {
103. ::WaitForSingleObject(m_hEvt,INFINITE);
104. }
106. voidKThread::SetProc(PTHREAD_FUNC_EXproc,void*lpParam)
107. {
108. ::WaitForSingleObject(m_hMtx,INFINITE);
109. m_param.proc=proc;
110. m_param.lpParam=lpParam;
111. ::ReleaseMutex(m_hMtx);
112. }
114. DWORDWINAPIKThread::RealThreadProc(void*lpParam)
115. {
116. PTHREAD_FUNC_EXproc;
117. KThreadParam*pp=(KThreadParam*)lpParam;
118. while(true)
119. {
120. proc=pp->proc;
121. if(proc)
122. (*proc)(pp->lpParam);
123. pp->proc=NULL;
124. pp->lpParam=NULL;
125. pp->pThread->Pause();
126. ::SetEvent(pp->pThread->m_hEvt);
127. }
128. }
129. //-------------------------------------------------------------------------
130. //KThread类定义结束
131. //-------------------------------------------------------------------------
135. //-------------------------------------------------------------------------
136. //KThreadPool类定义开始
137. //-------------------------------------------------------------------------
138. KThreadPool::KThreadPool(intinitNum)
139. {
140. KThread*pt;
141. for(inti=0;i<initNum;i++)
142. {
143. pt=newKThread;
144. if(pt->Init())
145. m_lst.push_back(pt);
146. }
147. }
149. KThreadPool::~KThreadPool()
150. {
151. list<KThread*>::iteratoritBegin=m_lst.begin();
152. list<KThread*>::iteratoritEnd=m_lst.end();
153. for(;itBegin!=itEnd;itBegin++)
154. {
155. delete(*itBegin);
156. }
157. }
159. DWORDKThreadPool::DoWork(LPTHREAD_START_ROUTINEproc,void*lpParam,boolrun)
160. {
161. list<KThread*>::iteratoritBegin=m_lst.begin();
162. list<KThread*>::iteratoritEnd=m_lst.end();
163. for(;itBegin!=itEnd;itBegin++)
164. {
165. if((*itBegin)->m_param.proc==NULL&&(*itBegin)->m_status==THREADPAUSE)
166. {
167. (*itBegin)->SetProc(proc,lpParam);
169. //立即运行
170. if(run)
171. (*itBegin)->Run();
172. return(*itBegin)->m_id;
173. }
174. }
176. //没有空闲线程，新建一个新的线程，加入链表
177. KThread*pt=newKThread;
178. if(pt->Init())
179. m_lst.push_back(pt);
180. pt->SetProc(proc,lpParam);
181. if(run)
182. pt->Run();
183. returnpt->m_id;
184. }
186. boolKThreadPool::Run(DWORDid)
187. {
188. list<KThread*>::iteratoritBegin=m_lst.begin();
189. list<KThread*>::iteratoritEnd=m_lst.end();
190. for(;itBegin!=itEnd;itBegin++)
191. {
192. if((*itBegin)->m_id==id)
193. return((*itBegin)->Run());
194. }
196. returnfalse;
197. }
199. boolKThreadPool::Pause(DWORDid)
200. {
201. list<KThread*>::iteratoritBegin=m_lst.begin();
202. list<KThread*>::iteratoritEnd=m_lst.end();
203. for(;itBegin!=itEnd;itBegin++)
204. {
205. if((*itBegin)->m_id==id)
206. return((*itBegin)->Pause());
207. }
209. returnfalse;
210. }
212. //-------------------------------------------------------------------------
213. //函数:KThreadPool::SetSize
214. //功能:修改线程池的大小
215. //返回值:unsigned
216. //参数:unsignedsize
217. //附注:如果小缩小线程池大小，谨慎使用
218. //-------------------------------------------------------------------------
219. unsignedKThreadPool::SetSize(unsignedsize)
220. {
221. unsignednowsize=m_lst.size();
222. if(nowsize<=size)
223. {
224. KThread*pt;
225. unsignedinc=size-nowsize;
226. for(unsignedi=0;i<inc;i++)
227. {
228. pt=newKThread;
229. if(pt->Init())
230. {
231. m_lst.push_back(pt);
232. }
233. }
234. returnsize;
235. }
236. else
237. {
238. unsigneddec=nowsize-size;
239. list<KThread*>::iteratorit=m_lst.begin();
240. list<KThread*>::iteratorite=m_lst.end();
241. list<KThread*>::iteratoritemp;
242. unsignedi=0;
243. for(;it!=ite&&i<dec;)
244. {
245. if((*it)->m_status==THREADPAUSE)
246. {
247. itemp=it++;
248. delete((*itemp));
249. m_lst.erase(itemp);
250. i++;
251. continue;
252. }
253. it++;
254. }
256. ::Sleep(100*i);
257. returnm_lst.size();
258. }
259. }
260. //-------------------------------------------------------------------------
261. //KThreadPool类定义结束
262. //-------------------------------------------------------------------------

使用：

要定义一个线程函数，然后再将该函数和线程数量设置到内存池中，测试代码如下：

1. DWORDWINAPIthreadFunc(LPVOIDlpThreadParam);
2. voidCKThreadPoolExDlg::OnBtnCreate()
3. {
4. statici=0;
5. if(!m_pThreadPool)
6. {
7. m_pThreadPool=newKThreadPool(1);
8. }
10. m_pThreadPool->DoWork(threadFunc,this,true);
11. i++;
12. if(i==4)
13. {
14. m_pThreadPool->SetSize(10);
15. }
16. }
18. voidCKThreadPoolExDlg::DoSomething()
19. {
20. //MessageBox("O(∩_∩)O哈哈~");
21. while(true)
22. {
23. ::EnterCriticalSection(&m_cs);
24. DWORDid=GetCurrentThreadId();
25. CStringcstr;
26. cstr.Format("线程%d正在运行...",id);
27. m_listInfo.InsertItem(m_listInfo.GetItemCount(),cstr);
28. ::LeaveCriticalSection(&m_cs);
29. ::Sleep(400);
30. }
31. }
33. DWORDWINAPIthreadFunc(LPVOIDlpThreadParam)
34. {
35. CKThreadPoolExDlg*pdlg=(CKThreadPoolExDlg*)lpThreadParam;
36. pdlg->DoSomething();
37. return0;
38. }

代码的详细注释我就不写了，想弄懂原理的还是好好研究下再使用，我不保证里面没有BUG。

再来看看内存池的原理，我下面的参考资料里面有几篇文章讲得不错，想了解原理的可以去看看。

如何更好的管理在应用程序中内存的使用，同时提高内存使用的效率，这是值得每一个开发人员深思的问题。内存池(Memory pool)提供了一种比较可行的解决方案。首先是创建内存池。这个过程的主要任务是预先分配足够大的内存，形成一个初步的“内存池”。分配内存，也就是用户请求内存时，会返回内存池中一块空闲的内存，并将其标志置为已使用，当然具体细节和方法有很多。释放内存时，不是真正地调用free或是delete的过程，而是把内存放回内存池的过程。在把内存放入内存池的同时，要把标志位置为空闲。最后在应用程序结束时，要把内存池销毁。这里主要做的工作就是把内存池中的每一块内存释放。

使用内存池的好处：

1、减少了内存碎片的产生。这个可以从创建内存池的过程中看出。我们在创建内存池时，分配的都是一块块比较整的内存块，这样可以减少内存碎片的产生。

2、提高了内存的使用效率。这个可以从分配内存和释放内存的过程中看出。每次的分配与释放并不是去调用系统提供的函数或是操作符去操作实际的内存，而是在复用内存池中的内存。

缺点就是很有可能会造成内存的浪费，原因也很明显，开始分配了一大块内存，不是全部都用得到的。

针对内存池，这里有两个实现，头一个很简单，用到了STL的队列来管理内存池指针，而且如果分配的内存没有显示的归还给内存池的话，即使内存池销毁的时候，这块内存也不会被销毁，就会有内存泄露，当然这个程序还可以改进，另外一个程序是根据：《C++应用程序性能优化》中提到的一种方法来实现的，程序见下面：

简单实现（还有很大的改进余地）：

1. /*-------------------------------------------------------------------------
2. //文件名：MemPool.h
3. //创建者：magicTong
4. //创建时间：2008-10-2417:50:00
5. //功能描述：一个简单的内存池实现
6. //
7. //$Id:$
8. //-----------------------------------------------------------------------*/
9. #ifndef__MEMPOOL_H__
10. #define__MEMPOOL_H__
12. //-------------------------------------------------------------------------
13. #include<queue>
15. #defineMemoryBlockSize1024
16. #defineMemoryBlockNum20
18. classKMemPool
19. {
20. public:
21. //构造
22. explicitKMemPool(inta_memoryBlockNum=MemoryBlockNum,
23. inta_memoryBlockSize=MemoryBlockSize);
24. //析构
25. virtual~KMemPool();
27. //两个主要的操作
28. intNewMemBuf(char*&a_recvBuff);
29. intDelMemBuf(char*a_recvBuff);
31. private:
32. void_initMemPool(inta_memoryBlockNum,inta_memoryBlockSize);
34. std::queue<char*>m_memPool;
35. };
37. //-------------------------------------------------------------------------
38. //$Log:$
40. #endif/*__MEMPOOL_H__*/

实现：

1. /*-------------------------------------------------------------------------
2. //文件名：MemPool.cpp
3. //创建者：magicTong
4. //创建时间：2008-10-2417:50:19
5. //功能描述：简单内存池实现
6. //
7. //$Id:$
8. //-----------------------------------------------------------------------*/
10. #include"stdafx.h"
11. #include"MemPool.h"
13. //-------------------------------------------------------------------------
15. //构造
16. KMemPool::KMemPool(inta_memoryBlockNum/*=MemoryBlockNum*/,
17. inta_memoryBlockSize/*=MemoryBlockSize*/)
18. {
19. _initMemPool(a_memoryBlockNum,a_memoryBlockSize);
20. }
22. //析构
23. KMemPool::~KMemPool()
24. {
25. char*l_tempBuff=NULL;
26. while(!m_memPool.empty())
27. {
28. l_tempBuff=m_memPool.front();
29. m_memPool.pop();
30. if(l_tempBuff)
31. {
32. //回收
33. delete[]l_tempBuff;
34. l_tempBuff=NULL;
35. }
36. }
37. }
39. //-------------------------------------------------------------------------
40. //函数:KMemPool::_initMemPool
41. //功能:
42. //返回值:void
43. //参数:inta_memoryBlockNum
44. //参数:inta_memoryBlockSize
45. //附注:
46. //-------------------------------------------------------------------------
47. voidKMemPool::_initMemPool(inta_memoryBlockNum,inta_memoryBlockSize)
48. {
49. for(inti=0;i<a_memoryBlockNum;++i)
50. {
51. char*l_tempBuff=newchar[a_memoryBlockSize];
52. if(l_tempBuff==NULL)
53. continue;
55. m_memPool.push(l_tempBuff);
56. }
58. }
60. //-------------------------------------------------------------------------
61. //函数:KMemPool::NewMemBuf
62. //功能:申请一块内存，如果内存池空了，这个时候应该再像系统申请，并且在
63. //类初始化的时候，加一个增量的变量，也可以提供这样的接口，这里为
64. //了简单就没有这么做了，只是为了说明问题而已。
65. //返回值:int
66. //参数:char*&a_memoryBuff
67. //附注:如果成功返回0，如果失败返回-1
68. //-------------------------------------------------------------------------
69. intKMemPool::NewMemBuf(char*&a_memoryBuff)
70. {
71. //如果内存池已空，这个时候正确的做法应该是
72. //重新申请大块内存
73. if(m_memPool.empty())
74. {
75. _initMemPool(MemoryBlockNum,MemoryBlockSize);
76. }
78. a_memoryBuff=m_memPool.front();
79. m_memPool.pop();
80. if(a_memoryBuff==NULL)
81. return-1;
83. return0;
84. }
86. //-------------------------------------------------------------------------
87. //函数:KMemPool::DelMemBuf
88. //功能:回收内存，将其放回队列中
89. //返回值:int
90. //参数:char*a_memoryBuff
91. //附注:
92. //-------------------------------------------------------------------------
93. intKMemPool::DelMemBuf(char*a_memoryBuff)
94. {
95. m_memPool.push(a_memoryBuff);
96. return0;
97. }
98. //-------------------------------------------------------------------------
99. //$Log:$

根据《C++应用程序性能优化》实现代码如下：

1. /*-------------------------------------------------------------------------
2. //文件名：MemPoolEx.h
3. //创建者：magicTong
4. //创建时间：2008-10-2417:49:33
5. //功能描述：
6. //
7. //$Id:$
8. //-----------------------------------------------------------------------*/
9. #ifndef__MEMPOOLEX_H__
10. #define__MEMPOOLEX_H__
12. //-------------------------------------------------------------------------
13. #include<Windows.h>
14. #defineMEMPOOL_ALIGNMENT4
16. classKMemBlock
17. {
18. public:
19. KMemBlock(USHORTnTypes=1,USHORTnUnitSize=0);
20. virtual~KMemBlock();
22. voidoperatordelete(void*p,size_t);
23. void*operatornew(size_t,USHORTnTypes,USHORTnUnitSize);
25. public:
26. USHORTnSize;//内存块的大小每个小块所占内存*小块个数
27. USHORTnFree;//空闲块数
28. USHORTnFirst;//第一个空闲块
29. //USHORTnDummyAlign1;
30. KMemBlock*pNext;//下一个Block
31. charaData[1];//数据的初始位置
33. };
35. classKMemPoolEx
36. {
37. public:
38. KMemPoolEx(USHORTuUnitSize,USHORTuInitSize,USHORTuGrowSize);
39. virtual~KMemPoolEx();
41. void*Alloc();
42. voidFree(void*pFree);
44. private:
45. void_FreeMemeoryBlock(KMemBlock*pMyBlock);
47. KMemBlock*pBlock;//第一个block的指针
48. USHORTnUnitSize;//每个小内存块的字节数
49. USHORTnInitSize;//初始的Block的内存块数目
50. USHORTnGrowSize;//增加的Block的内存块数目
51. };
52. //-------------------------------------------------------------------------
53. //$Log:$
55. #endif/*__MEMPOOLEX_H__*/

实现部分：

1. /*-------------------------------------------------------------------------
2. //文件名：MemPoolEx.cpp
3. //创建者：magicTong
4. //创建时间：2008-10-2417:49:45
5. //功能描述：
6. //
7. //$Id:$
8. //-----------------------------------------------------------------------*/
10. #include"stdafx.h"
11. #include"MemPoolEx.h"
14. //-------------------------------------------------------------------------
15. //构造
16. KMemBlock::KMemBlock(USHORTnTypes,USHORTnUnitSize)
17. {
18. nFree=nTypes-1;
19. pNext=NULL;
20. nSize=nTypes*nUnitSize;
21. nFirst=1;
23. char*pData=aData;
24. for(USHORTi=1;i<nTypes;i++)
25. {
26. *(USHORT*)pData=i;
27. pData+=nUnitSize;
28. }
29. }
31. //析构
32. KMemBlock::~KMemBlock()
33. {
34. }
36. //-------------------------------------------------------------------------
37. //函数:KMemBlock::operatornew
38. //功能:
39. //返回值:void*
40. //参数:size_t
41. //参数:USHORTnTypes
42. //参数:USHORTnUnitSize
43. //附注:
44. //-------------------------------------------------------------------------
45. void*KMemBlock::operatornew(size_t,USHORTnTypes,USHORTnUnitSize)
46. {
47. return::operatornew(sizeof(KMemBlock)+nTypes*nUnitSize);
48. }
50. //-------------------------------------------------------------------------
51. //函数:KMemBlock::operatordelete
52. //功能:
53. //返回值:void
54. //参数:void*p
55. //参数:size_t
56. //附注:
57. //-------------------------------------------------------------------------
58. voidKMemBlock::operatordelete(void*p,size_t)
59. {
60. ::operatordelete(p);
61. }
64. //-------------------------------------------------------------------------
65. //线程池定义
66. //-------------------------------------------------------------------------
67. //构造
68. //_uUnitSize每个小内存块的字节数
69. //_uInitSize是初始的Block的内存块数目
70. //_uGrowSize增加的Block的内存块数目
71. KMemPoolEx::KMemPoolEx(USHORT_uUnitSize,USHORT_uInitSize,USHORT_uGrowSize)
72. {
73. pBlock=NULL;
74. nInitSize=_uInitSize;
75. nGrowSize=_uGrowSize;
77. if(_uUnitSize<=2)
78. nUnitSize=2;
79. elseif(_uUnitSize>2&&_uUnitSize<=4)
80. nUnitSize=4;
81. else
82. {
83. if(_uUnitSize%MEMPOOL_ALIGNMENT==0)
84. nUnitSize=_uUnitSize;
85. else
86. nUnitSize=(_uUnitSize/MEMPOOL_ALIGNMENT+1)*MEMPOOL_ALIGNMENT;
87. }
88. }
90. //析构
91. KMemPoolEx::~KMemPoolEx()
92. {
93. KMemBlock*pMyBlock=pBlock;
94. if(pBlock)
95. _FreeMemeoryBlock(pMyBlock);
96. }
98. //-------------------------------------------------------------------------
99. //函数:KMemPool::_FreeMemeoryBlock
100. //功能:递归释放内存
101. //返回值:void
102. //参数:KMemBlock*pMyBlock
103. //附注:其实这个地方没必要使用递归，迭代实现很容易
104. //-------------------------------------------------------------------------
105. voidKMemPoolEx::_FreeMemeoryBlock(KMemBlock*pMyBlock)
106. {
107. if(pMyBlock->pNext)
108. _FreeMemeoryBlock(pMyBlock->pNext);
110. deletepMyBlock;
111. }
113. //-------------------------------------------------------------------------
114. //函数:KMemPoolEx::Alloc
115. //功能:申请内存
116. //返回值:void*
117. //附注:
118. //-------------------------------------------------------------------------
119. void*KMemPoolEx::Alloc()
120. {
121. if(!pBlock)
122. {
123. //如果是第一次申请
124. pBlock=new(nInitSize,nUnitSize)KMemBlock(nInitSize,nUnitSize);
125. returnpBlock->aData;
126. }
128. //如果不是第一次申请
129. KMemBlock*pMyBlock=pBlock;
130. while(pMyBlock&&!pMyBlock->nFree)
131. pMyBlock=pMyBlock->pNext;
133. //接下来的两种情况：1.找到有空闲块的block2.找不到
134. void*retval;
136. //找到了空闲块
137. if(pMyBlock)
138. {
139. pMyBlock->nFree--;
140. retval=pMyBlock->aData+nUnitSize*pMyBlock->nFirst;
141. pMyBlock->nFirst=*((USHORT*)retval);
142. returnretval;
143. }
144. //没有找到空闲块，要重新申请
145. else
146. {
147. if(!nGrowSize)
148. returnNULL;
149. KMemBlock*newBlock=new(nGrowSize,nUnitSize)KMemBlock(nGrowSize,nUnitSize);
150. if(!newBlock)
151. returnNULL;
152. newBlock->pNext=pBlock;
153. pBlock=newBlock;
154. return(void*)(newBlock->aData);
155. }
157. returnNULL;
158. }
160. //-------------------------------------------------------------------------
161. //函数:KMemPoolEx::Free
162. //功能:释放内存
163. //返回值:void
164. //参数:void*pFree
165. //附注:释放内存时，并不真正的归还给堆，而且是回收到内存池中
166. //-------------------------------------------------------------------------
167. voidKMemPoolEx::Free(void*pFree)
168. {
169. KMemBlock*pMyBlock=pBlock;
170. KMemBlock*pPreBlock=NULL;//pMyBlock指向Block的前一个Block，用于设置pNext
172. //如果要求释放的内存并不是内存池里面的内存，则直接返回，不予释放
173. while((ULONG)pFree<(ULONG)pMyBlock->aData||(ULONG)pFree>(ULONG)(pMyBlock->aData+pMyBlock->nSize))
174. {
175. pPreBlock=pMyBlock;
176. pMyBlock=pMyBlock->pNext;
178. if(!pMyBlock)
179. return;
180. }
182. //是内存池里面分配出去的，回收到内存池，并不真正归还给堆
183. if(pMyBlock)
184. {
185. pMyBlock->nFree++;
186. *((USHORT*)pFree)=pMyBlock->nFirst;
187. pMyBlock->nFirst=(USHORT)(((ULONG)pFree-(ULONG)pMyBlock->aData)/nUnitSize);
189. if(pMyBlock->nFree*nUnitSize==pMyBlock->nSize)//如果全是自由块
190. {
191. if(!pMyBlock->pNext)//如果这是最后一个block,则将其释放
192. {
193. deletepMyBlock;//释放
194. if(pPreBlock)
195. pPreBlock->pNext=NULL;//设置上一块的pNext指向NULL
196. else
197. pBlock=NULL;
198. }
200. }
201. }
202. }
204. //-------------------------------------------------------------------------
205. //$Log:$

数据库连接池是因为，初始化一个数据库连接是非常消耗系统资源的，因此就在程序开始阶段进行数据库的批量连接，然后把这些连接保存下来，等到要使用的时候才拿出来使用，使用完了再放入连接池中。了解不深就不多说了。

参考资料：

CSDN博客：许式伟 著内存池(MemPool)技术详解http://blog.csdn.net/xushiweizh/archive/2006/11/22/1402967.aspx

IBM技术文档：内存池http://www.ibm.com/developerworks/cn/linux/l-cn-ppp/index6.html?ca=drs-cn

Java中数据库连接池原理机制讲解：http://www.68design.net/Development/JSP/20703-1.html