“池化技術”漫談 - 線程池，內存池，連接池……

池化技術 - 簡單點來說，就是提前保存大量的資源，以備不時之需，O(∩_∩)O，對於線程，內存，oracle的連接對象等等，這些都是資源，程序中當你創建一個線程或者在堆上申請一塊內存時，都涉及到很多系統調用，也是非常消耗CPU的，如果你的程序需要很多類似的工作線程或者需要頻繁的申請釋放小塊內存，如果沒有在這方面進行優化，那很有可能這部分代碼將會成爲影響你整個程序性能的瓶頸。池化技術主要有線程池，內存池，連接池，對象池等等，對象池就是提前創建很多對象，將用過的對象保存起來，等下一次需要這種對象的時候，再拿出來重複使用，連接池比較典型的有oracle的連接池，瞭解不深。

下面主要談談線程池和內存池，因爲這兩種技術的通用性和實用性也是比較強的，描述語言C++，其實線程池的話用什麼實現都可以。

先來談談線程池技術，線程池的框架早就有先輩給我們想好了，也就不用我們去冥思苦想了，我們要做的就是把先輩的想法發現即可。

其實線程池的原理很簡單，類似於操作系統中的緩衝區的概念，它的流程如下：先啓動若干數量的線程，並讓這些線程都處於睡眠狀態，當客戶端有一個新請求時，就會喚醒線程池中的某一個睡眠線程，讓它來處理客戶端的這個請求，當處理完這個請求後，線程又處於睡眠狀態。可能你也許會問：爲什麼要搞得這麼麻煩，如果每當客戶端有新的請求時，我就創建一個新的線程不就完了？這也許是個不錯的方法，因爲它能使得你編寫代碼相對容易一些，但你卻忽略了一個重要的問題？性能！尤其是對於服務器程序尤爲重要，服務器程序會先初始化很多線程在那裏等待，當有客戶連接時，就激活其中的一個線程來處理客戶請求，對於不支持動態增加的線程池，如果沒有等待線程，客戶就必學等待，而對於能動態增加線程的線程池，則可以像線程池中新加一個線程。

下面是一個用c++實現的線程池，支持動態增減線程數量：

/* -------------------------------------------------------------------------
//  文件名     ：   KThreadPool.h
//  創建者     ：   magicTong
//  創建時間    ：   2008-10-23 15:02:31
//  功能描述    ：   線程池聲明
//
//  $Id: $
// -----------------------------------------------------------------------*/
#ifndef __KTHREADPOOL_H__
#define __KTHREADPOOL_H__
// -------------------------------------------------------------------------
#include <windows.h>
#include <list>
using namespace std;
// 線程函數指針定義  
typedef DWORD (WINAPI *PTHREAD_FUNC_EX)(LPVOID lpThreadParameter);
// 線程狀態枚舉
typedef enum _enumKThreadStatus
{
    THREADRUN,      // 運行
    THREADPAUSE,    // 暫停
}
KThreadStatus;
// -------------------------------------------------------------------------
// 類名       : KThread
// 功能       : 線程類，可動態更換執行函數
// 附註       : 
// -------------------------------------------------------------------------
class KThread
{
public:
    // 構造
    KThread();
    // 析構 
    ~KThread();
    // -------------------------------------------------------------------------
    // 函數       : Init
    // 功能       : 初始化函數
    // 返回值  : bool 
    // 附註       : 
    // -------------------------------------------------------------------------
    bool Init();
    // -------------------------------------------------------------------------
    // 函數       : Run
    // 功能       : 運行線程
    // 返回值  : bool 
    // 附註       : 
    // -------------------------------------------------------------------------
    bool Run();
    // -------------------------------------------------------------------------
    // 函數       : Pause
    // 功能       : 暫停線程
    // 返回值  : bool 
    // 附註       : 
    // -------------------------------------------------------------------------
    bool Pause();
    // -------------------------------------------------------------------------
    // 函數       : Join
    // 功能       : 調用Join的線程將阻塞，直到該線程執行完畢
    // 返回值  : void 
    // 附註       : 
    // -------------------------------------------------------------------------
    void Join();
    // -------------------------------------------------------------------------
    // 函數       : SetProc
    // 功能       : 設置線程運行的函數，和要傳給線程的參數
    // 返回值  : void 
    // 參數       : PTHREAD_FUNC_EX proc
    // 參數       : void* lpParam
    // 附註       : 
    // -------------------------------------------------------------------------
    void SetProc(PTHREAD_FUNC_EX proc, void* lpParam);
protected:
    KThread(KThread&){}
    // 線程實際運行的函數
    static DWORD WINAPI RealThreadProc(void* lpParam);
    friend class KThreadPool;
protected:
    struct KThreadParam
    {
        PTHREAD_FUNC_EX proc;   // 用戶線程函數
        void *lpParam;          // 用戶線程參數
        KThread *pThread;       // 線程類對象
    };
    HANDLE              m_hThread;
    DWORD               m_id;
    KThreadParam        m_param;
    KThreadStatus       m_status;
    HANDLE              m_hEvt;
    HANDLE              m_hMtx;
};
// -------------------------------------------------------------------------
// 類名       : KThreadPool
// 功能       : 線程池類聲明
// 附註       : 
// -------------------------------------------------------------------------
class KThreadPool
{
public:
    //構造，initNum初始情況線程數量
    KThreadPool(int initNum);
    //析構 
    ~KThreadPool();
    // -------------------------------------------------------------------------
    // 函數       : DoWork
    // 功能       : 申請線程進行工作，proc工作函數，lpParam工作函數參數，run是否立即運行，返回線程ID
    // 返回值  : DWORD 
    // 參數       : PTHREAD_FUNC_EX proc
    // 參數       : void *lpParam
    // 參數       : bool run = true
    // 附註       : 
    // -------------------------------------------------------------------------
    DWORD DoWork(PTHREAD_FUNC_EX proc, void *lpParam, bool run = true);
    // -------------------------------------------------------------------------
    // 函數       : Run
    // 功能       : 運行線程，id線程ID
    // 返回值  : bool 
    // 參數       : DWORD id
    // 附註       : 
    // -------------------------------------------------------------------------
    bool Run(DWORD id);
    // -------------------------------------------------------------------------
    // 函數       : Pause
    // 功能       : 暫停運行線程，id線程ID
    // 返回值  : bool 
    // 參數       : DWORD id
    // 附註       : 
    // -------------------------------------------------------------------------
    bool Pause(DWORD id);
    //調整線程池大小爲size，返回調整後線程池大小
    unsigned SetSize(unsigned size);
protected:
    list<KThread*> m_lst;
};

實現：

/* -------------------------------------------------------------------------
//  文件名     ：   KThreadPool.cpp
//  創建者     ：   magicTong
//  創建時間    ：   2008-10-23 15:02:22
//  功能描述    ：   線程池定義
//
//  $Id: $
// -----------------------------------------------------------------------*/
#include "stdafx.h"
#include "KThreadPool.h"
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
// KThread類定義開始
// -------------------------------------------------------------------------
KThread::KThread(): m_hThread(NULL), 
                    m_status(THREADPAUSE), 
                    m_hEvt(0), 
                    m_hMtx(0)
{
}
KThread::~KThread()
{
    ::CloseHandle(m_hMtx);
    if (::TerminateThread(m_hThread, -1) == 0)
        return;
}
bool KThread::Init()
{
    m_hThread = ::CreateThread(
                                0, 
                                0, 
                                (PTHREAD_FUNC_EX)(KThread::RealThreadProc),
                                (void*)&m_param, 
                                CREATE_SUSPENDED, 
                                &m_id);
    // 創建線程失敗
    if (NULL == m_hThread)
    {
        return false;
    }
    m_param.proc = NULL;
    m_param.lpParam = NULL;
    m_param.pThread = this;
    //自動復位
    m_hEvt = ::CreateEvent(0, FALSE, FALSE, 0);
    if (m_hEvt == 0)
    {
        ::CloseHandle(m_hThread);
        return false;
    }
    m_hMtx = ::CreateMutex(0, 0, 0);
    if (m_hMtx == 0)
    {
        ::CloseHandle(m_hEvt);
        ::CloseHandle(m_hThread);
        return false;
    }
    return true;
}
bool KThread::Run()
{
    ::WaitForSingleObject(m_hMtx, INFINITE);
    if (m_status == THREADPAUSE)
        if (::ResumeThread(m_hThread) == -1)
        {
            ::ReleaseMutex(m_hMtx);
            return false;
        }
    
    m_status = THREADRUN;
    ::ReleaseMutex(m_hMtx);
    return true;
}
bool KThread::Pause()
{
    ::WaitForSingleObject(m_hMtx, INFINITE);
    if (m_status == THREADRUN)
        if (::SuspendThread(m_hThread) == -1)
        {
            ::ReleaseMutex(m_hMtx);
            return false;
        }
    m_status = THREADPAUSE;
    ::ReleaseMutex(m_hMtx);
    return true;
}
void KThread::Join()
{
    ::WaitForSingleObject(m_hEvt, INFINITE);
}
void KThread::SetProc(PTHREAD_FUNC_EX proc, void* lpParam)
{
    ::WaitForSingleObject(m_hMtx, INFINITE);
    m_param.proc = proc;
    m_param.lpParam = lpParam;
    ::ReleaseMutex(m_hMtx);
}
DWORD WINAPI KThread::RealThreadProc(void* lpParam)
{
    PTHREAD_FUNC_EX proc;
    KThreadParam *pp = (KThreadParam*)lpParam;
    while (true)
    {
        proc = pp->proc;
        if (proc)
            (*proc)(pp->lpParam);
        pp->proc = NULL;
        pp->lpParam = NULL;
        pp->pThread->Pause();
        ::SetEvent(pp->pThread->m_hEvt);
    }
}
// -------------------------------------------------------------------------
// KThread類定義結束
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
// KThreadPool類定義開始
// -------------------------------------------------------------------------
KThreadPool::KThreadPool(int initNum)
{
    KThread *pt;
    for (int i = 0; i < initNum; i++)
    {
        pt = new KThread;
        if (pt->Init())
            m_lst.push_back(pt);
    }
}
KThreadPool::~KThreadPool()
{
    list<KThread*>::iterator itBegin = m_lst.begin();
    list<KThread*>::iterator itEnd = m_lst.end();
    for ( ; itBegin != itEnd; itBegin++)
    {
        delete (*itBegin);
    }
}
DWORD KThreadPool::DoWork(LPTHREAD_START_ROUTINE proc, void *lpParam, bool run)
{
    list<KThread*>::iterator itBegin = m_lst.begin();
    list<KThread*>::iterator itEnd = m_lst.end();
    for (; itBegin != itEnd; itBegin++)
    {
        if ((*itBegin)->m_param.proc == NULL && (*itBegin)->m_status == THREADPAUSE)
        {
            (*itBegin)->SetProc(proc, lpParam);
            
            // 立即運行
            if (run)
                (*itBegin)->Run();
            return (*itBegin)->m_id;
        }
    }
    // 沒有空閒線程，新建一個新的線程，加入鏈表
    KThread *pt = new KThread;
    if (pt->Init())
        m_lst.push_back(pt);
    pt->SetProc(proc, lpParam);
    if (run)
        pt->Run();
    return pt->m_id;
}
bool KThreadPool::Run(DWORD id)
{
    list<KThread*>::iterator itBegin = m_lst.begin();
    list<KThread*>::iterator itEnd = m_lst.end();
    for (; itBegin != itEnd; itBegin++)
    {
        if ((*itBegin)->m_id == id)
        return ((*itBegin)->Run());
    }
    return false;
}
bool KThreadPool::Pause(DWORD id)
{
    list<KThread*>::iterator itBegin = m_lst.begin();
    list<KThread*>::iterator itEnd = m_lst.end();
    for (; itBegin != itEnd; itBegin++)
    {
        if ((*itBegin)->m_id == id)
            return ((*itBegin)->Pause());
    }
    
    return false;
}
// -------------------------------------------------------------------------
// 函數       : KThreadPool::SetSize
// 功能       : 修改線程池的大小
// 返回值  : unsigned 
// 參數       : unsigned size
// 附註       : 如果小縮小線程池大小，謹慎使用
// -------------------------------------------------------------------------
unsigned KThreadPool::SetSize(unsigned size)
{
    unsigned nowsize = m_lst.size();
    if (nowsize <= size)
    {
        KThread *pt;
        unsigned inc = size - nowsize;
        for (unsigned i = 0; i < inc; i++)
        {
            pt = new KThread;
            if (pt->Init())
            {
                m_lst.push_back(pt);
            }
        }
        return size;
    }
    else
    {
        unsigned dec = nowsize - size;
        list<KThread*>::iterator it = m_lst.begin();
        list<KThread*>::iterator ite = m_lst.end();
        list<KThread*>::iterator itemp;
        unsigned i = 0;
        for (; it != ite && i < dec;)
        {
            if ((*it)->m_status == THREADPAUSE)
            {
                itemp = it++;
                delete ((*itemp));
                m_lst.erase(itemp);
                i++;
                continue;
            }
            it++;
        }
        ::Sleep(100 * i);
        return m_lst.size();
    }
}
// -------------------------------------------------------------------------
// KThreadPool類定義結束
// -------------------------------------------------------------------------

使用：

要定義一個線程函數，然後再將該函數和線程數量設置到內存池中，測試代碼如下：

DWORD WINAPI threadFunc(LPVOID lpThreadParam);
void CKThreadPoolExDlg::OnBtnCreate() 
{
    static i = 0;
    if (!m_pThreadPool)
    {
        m_pThreadPool = new KThreadPool(1);
    }
    
    m_pThreadPool->DoWork(threadFunc, this, true);
    i++;
    if (i == 4)
    {
        m_pThreadPool->SetSize(10);
    }
}
void CKThreadPoolExDlg::DoSomething()
{
    //MessageBox("O(∩_∩)O哈哈~");
    while (true)
    {
        ::EnterCriticalSection(&m_cs);
        DWORD id = GetCurrentThreadId();
        CString cstr;
        cstr.Format("線程 %d 正在運行...", id);
        m_listInfo.InsertItem(m_listInfo.GetItemCount(), cstr);
        ::LeaveCriticalSection(&m_cs);
        ::Sleep(400);
    }
}
DWORD WINAPI threadFunc(LPVOID lpThreadParam)
{
    CKThreadPoolExDlg *pdlg = (CKThreadPoolExDlg *)lpThreadParam;
    pdlg->DoSomething();
    return 0;
}

代碼的詳細註釋我就不寫了，想弄懂原理的還是好好研究下再使用，我不保證裏面沒有BUG。

再來看看內存池的原理，我下面的參考資料裏面有幾篇文章講得不錯，想了解原理的可以去看看。

如何更好的管理在應用程序中內存的使用，同時提高內存使用的效率，這是值得每一個開發人員深思的問題。內存池(Memory pool)提供了一種比較可行的解決方案。首先是創建內存池。這個過程的主要任務是預先分配足夠大的內存，形成一個初步的“內存池”。分配內存，也就是用戶請求內存時，會返回內存池中一塊空閒的內存，並將其標誌置爲已使用，當然具體細節和方法有很多。釋放內存時，不是真正地調用free或是delete的過程，而是把內存放回內存池的過程。在把內存放入內存池的同時，要把標誌位置爲空閒。最後在應用程序結束時，要把內存池銷燬。這裏主要做的工作就是把內存池中的每一塊內存釋放。

使用內存池的好處：

1、減少了內存碎片的產生。這個可以從創建內存池的過程中看出。我們在創建內存池時，分配的都是一塊塊比較整的內存塊，這樣可以減少內存碎片的產生。

2、提高了內存的使用效率。這個可以從分配內存和釋放內存的過程中看出。每次的分配與釋放並不是去調用系統提供的函數或是操作符去操作實際的內存，而是在複用內存池中的內存。

缺點就是很有可能會造成內存的浪費，原因也很明顯，開始分配了一大塊內存，不是全部都用得到的。

針對內存池，這裏有兩個實現，頭一個很簡單，用到了STL的隊列來管理內存池指針，而且如果分配的內存沒有顯示的歸還給內存池的話，即使內存池銷燬的時候，這塊內存也不會被銷燬，就會有內存泄露，當然這個程序還可以改進，另外一個程序是根據：《C++應用程序性能優化》中提到的一種方法來實現的，程序見下面：

簡單實現（還有很大的改進餘地）：

/* -------------------------------------------------------------------------
//  文件名     ：   MemPool.h
//  創建者     ：   magicTong
//  創建時間    ：   2008-10-24 17:50:00
//  功能描述    ：  一個簡單的內存池實現
//
//  $Id: $
// -----------------------------------------------------------------------*/
#ifndef __MEMPOOL_H__
#define __MEMPOOL_H__
// -------------------------------------------------------------------------
#include <queue>
#define  MemoryBlockSize    1024
#define  MemoryBlockNum     20
class KMemPool
{
public:
    // 構造 
    explicit KMemPool(int a_memoryBlockNum = MemoryBlockNum, 
                        int a_memoryBlockSize = MemoryBlockSize);
    // 析構
    virtual ~KMemPool();
    // 兩個主要的操作
    int NewMemBuf(char*& a_recvBuff);
    int DelMemBuf(char* a_recvBuff);
private:
    void _initMemPool(int a_memoryBlockNum, int a_memoryBlockSize);
    std::queue<char*> m_memPool;
};
// -------------------------------------------------------------------------
// $Log: $
#endif /* __MEMPOOL_H__ */

實現：

/* -------------------------------------------------------------------------
//  文件名     ：   MemPool.cpp
//  創建者     ：   magicTong
//  創建時間    ：   2008-10-24 17:50:19
//  功能描述    ：   簡單內存池實現
//
//  $Id: $
// -----------------------------------------------------------------------*/
#include "stdafx.h"
#include "MemPool.h"
// -------------------------------------------------------------------------
// 構造 
KMemPool::KMemPool(int a_memoryBlockNum /* = MemoryBlockNum */, 
                   int a_memoryBlockSize /* = MemoryBlockSize */)
{
    _initMemPool(a_memoryBlockNum, a_memoryBlockSize);
}
// 析構
KMemPool::~KMemPool()
{
    char* l_tempBuff = NULL;
    while(!m_memPool.empty())
    {
        l_tempBuff = m_memPool.front();
        m_memPool.pop();
        if(l_tempBuff )
        {
            // 回收
            delete[] l_tempBuff;
            l_tempBuff = NULL;
        }
    }
}
// -------------------------------------------------------------------------
// 函數       : KMemPool::_initMemPool
// 功能       : 
// 返回值  : void 
// 參數       : int a_memoryBlockNum
// 參數       : int a_memoryBlockSize
// 附註       : 
// -------------------------------------------------------------------------
void KMemPool::_initMemPool(int a_memoryBlockNum, int a_memoryBlockSize)
{
    for(int i = 0; i < a_memoryBlockNum; ++i)
    {
        char* l_tempBuff = new char[a_memoryBlockSize];
        if(l_tempBuff == NULL)
            continue;
        m_memPool.push(l_tempBuff);
    }
    
}
// -------------------------------------------------------------------------
// 函數       : KMemPool::NewMemBuf
// 功能       : 申請一塊內存，如果內存池空了，這個時候應該再像系統申請，並且在
//            類初始化的時候，加一個增量的變量，也可以提供這樣的接口，這裏爲
//            了簡單就沒有這麼做了，只是爲了說明問題而已。
// 返回值  : int 
// 參數       : char*& a_memoryBuff
// 附註       : 如果成功返回0，如果失敗返回-1
// -------------------------------------------------------------------------
int KMemPool::NewMemBuf(char*& a_memoryBuff)
{
    // 如果內存池已空，這個時候正確的做法應該是
    // 重新申請大塊內存
    if (m_memPool.empty())
    {
        _initMemPool(MemoryBlockNum, MemoryBlockSize);
    }
    a_memoryBuff = m_memPool.front();
    m_memPool.pop();
    if(a_memoryBuff == NULL)
        return -1;
    return 0;
}
// -------------------------------------------------------------------------
// 函數       : KMemPool::DelMemBuf
// 功能       : 回收內存，將其放回隊列中
// 返回值  : int 
// 參數       : char* a_memoryBuff
// 附註       : 
// -------------------------------------------------------------------------
int KMemPool::DelMemBuf(char* a_memoryBuff)
{
    m_memPool.push(a_memoryBuff);
    return 0;
}
// -------------------------------------------------------------------------
// $Log: $

根據《C++應用程序性能優化》實現代碼如下：

/* -------------------------------------------------------------------------
//  文件名     ：   MemPoolEx.h
//  創建者     ：   magicTong
//  創建時間    ：   2008-10-24 17:49:33
//  功能描述    ：   
//
//  $Id: $
// -----------------------------------------------------------------------*/
#ifndef __MEMPOOLEX_H__
#define __MEMPOOLEX_H__
// -------------------------------------------------------------------------
#include <Windows.h>
#define MEMPOOL_ALIGNMENT 4
class KMemBlock  
{
public:
    KMemBlock(USHORT nTypes = 1, USHORT nUnitSize = 0);    
    virtual ~KMemBlock();
    
    void  operator delete(void *p, size_t);
    void * operator new (size_t, USHORT nTypes, USHORT nUnitSize);    
    
public:
    USHORT          nSize;              // 內存塊的大小  每個小塊所佔內存*小塊個數
    USHORT          nFree;              // 空閒塊數
    USHORT          nFirst;             // 第一個空閒塊
    //USHORT          nDummyAlign1;        
    KMemBlock       *pNext;             // 下一個Block
    char            aData[1];           // 數據的初始位置
};
class KMemPoolEx  
{
public:
    KMemPoolEx(USHORT uUnitSize, USHORT uInitSize, USHORT uGrowSize);
    virtual ~KMemPoolEx();
    
    void* Alloc();
    void Free(void* pFree);
    
private:
    void _FreeMemeoryBlock(KMemBlock* pMyBlock);
    
    KMemBlock*      pBlock;         // 第一個block的指針 
    USHORT          nUnitSize;      // 每個小內存塊的字節數
    USHORT          nInitSize;      // 初始的Block的內存塊數目
    USHORT          nGrowSize;      // 增加的Block的內存塊數目
};
// -------------------------------------------------------------------------
// $Log: $ 
#endif /* __MEMPOOLEX_H__ */

實現部分：

/* -------------------------------------------------------------------------
//  文件名     ：   MemPoolEx.cpp
//  創建者     ：   magicTong
//  創建時間    ：   2008-10-24 17:49:45
//  功能描述    ：   
//
//  $Id: $
// -----------------------------------------------------------------------*/
#include "stdafx.h" 
#include "MemPoolEx.h" 
// ------------------------------------------------------------------------- 
// 構造  
KMemBlock::KMemBlock (USHORT nTypes, USHORT nUnitSize)
{
    nFree = nTypes - 1;
    pNext = NULL;
    nSize = nTypes * nUnitSize;
    nFirst = 1;
    char* pData = aData;
    for(USHORT i = 1; i < nTypes; i++)
    {
        *(USHORT *)pData = i;
        pData += nUnitSize;
    }
}
// 析構  
KMemBlock::~KMemBlock()
{
}
// ------------------------------------------------------------------------- 
// 函數       : KMemBlock::operator new 
// 功能       :  
// 返回值  : void *  
// 參數       : size_t 
// 參數       : USHORT nTypes 
// 參數       : USHORT nUnitSize 
// 附註       :  
// ------------------------------------------------------------------------- 
void * KMemBlock::operator new(size_t, USHORT nTypes, USHORT nUnitSize)
{
    return ::operator new (sizeof(KMemBlock) + nTypes * nUnitSize);
}
// ------------------------------------------------------------------------- 
// 函數       : KMemBlock::operator delete 
// 功能       :  
// 返回值  : void   
// 參數       : void *p 
// 參數       : size_t 
// 附註       :  
// ------------------------------------------------------------------------- 
void  KMemBlock::operator delete(void *p, size_t)
{
    ::operator delete (p);
}
// ------------------------------------------------------------------------- 
// 線程池定義  
// ------------------------------------------------------------------------- 
// 構造  
// _uUnitSize 每個小內存塊的字節數 
// _uInitSize 是初始的Block的內存塊數目 
// _uGrowSize 增加的Block的內存塊數目 
KMemPoolEx::KMemPoolEx(USHORT _uUnitSize, USHORT _uInitSize, USHORT _uGrowSize)
{
    pBlock = NULL;
    nInitSize = _uInitSize;
    nGrowSize = _uGrowSize;
    
    if(_uUnitSize <= 2)
        nUnitSize = 2;
    else if(_uUnitSize > 2 && _uUnitSize <= 4)
        nUnitSize = 4;
    else 
    {
        if(_uUnitSize % MEMPOOL_ALIGNMENT == 0)
            nUnitSize = _uUnitSize;
        else
            nUnitSize = (_uUnitSize / MEMPOOL_ALIGNMENT + 1) * MEMPOOL_ALIGNMENT;
    }
}
// 析構 
KMemPoolEx::~KMemPoolEx()
{
    KMemBlock* pMyBlock = pBlock;
    if(pBlock)
        _FreeMemeoryBlock(pMyBlock);
}
// ------------------------------------------------------------------------- 
// 函數       : KMemPool::_FreeMemeoryBlock 
// 功能       : 遞歸釋放內存 
// 返回值  : void  
// 參數       : KMemBlock *pMyBlock 
// 附註       : 其實這個地方沒必要使用遞歸，迭代實現很容易 
// ------------------------------------------------------------------------- 
void KMemPoolEx::_FreeMemeoryBlock(KMemBlock *pMyBlock)
{
    if(pMyBlock->pNext)
        _FreeMemeoryBlock(pMyBlock->pNext);
    delete pMyBlock;
}
// ------------------------------------------------------------------------- 
// 函數       : KMemPoolEx::Alloc 
// 功能       : 申請內存 
// 返回值  : void*  
// 附註       :  
// ------------------------------------------------------------------------- 
void* KMemPoolEx::Alloc()
{
    if(!pBlock)
    {
        // 如果是第一次申請 
        pBlock = new (nInitSize, nUnitSize) KMemBlock(nInitSize, nUnitSize);
        return pBlock->aData;
    }
    // 如果不是第一次申請 
    KMemBlock *pMyBlock = pBlock;
    while(pMyBlock && !pMyBlock->nFree)
        pMyBlock = pMyBlock->pNext;
    //接下來的兩種情況：1.找到有空閒塊的block 2.找不到 
    void *retval;
    // 找到了空閒塊 
    if(pMyBlock)
    {
        pMyBlock->nFree--;
        retval = pMyBlock->aData + nUnitSize * pMyBlock->nFirst;
        pMyBlock->nFirst = *((USHORT*)retval);
        return retval;
    }
    // 沒有找到空閒塊，要重新申請 
    else
    {
        if(!nGrowSize)
            return NULL;
        KMemBlock* newBlock = new (nGrowSize, nUnitSize) KMemBlock(nGrowSize, nUnitSize);
        if(!newBlock)
            return NULL;
        newBlock->pNext = pBlock;
        pBlock = newBlock;
        return (void*)(newBlock->aData);
    }
    
    return NULL;
}
// ------------------------------------------------------------------------- 
// 函數       : KMemPoolEx::Free 
// 功能       : 釋放內存 
// 返回值  : void  
// 參數       : void* pFree 
// 附註       : 釋放內存時，並不真正的歸還給堆，而且是回收到內存池中 
// ------------------------------------------------------------------------- 
void KMemPoolEx::Free(void* pFree)
{
    KMemBlock* pMyBlock = pBlock;
    KMemBlock* pPreBlock = NULL;    //pMyBlock指向Block的前一個Block，用於設置pNext 
    // 如果要求釋放的內存並不是內存池裏面的內存，則直接返回，不予釋放 
    while((ULONG)pFree < (ULONG)pMyBlock->aData || (ULONG)pFree > (ULONG)(pMyBlock->aData + pMyBlock->nSize))
    {
        pPreBlock = pMyBlock;
        pMyBlock = pMyBlock->pNext;
        if(!pMyBlock)
            return;
    }
    // 是內存池裏面分配出去的，回收到內存池，並不真正歸還給堆 
    if(pMyBlock)
    {
        pMyBlock->nFree++;
        *((USHORT*)pFree) = pMyBlock->nFirst;
        pMyBlock->nFirst = (USHORT)(((ULONG)pFree - (ULONG)pMyBlock->aData) / nUnitSize);
        
        if(pMyBlock->nFree * nUnitSize == pMyBlock->nSize)   //如果全是自由塊 
        {
            if(!pMyBlock->pNext)  //如果這是最後一個block,則將其釋放 
            {
                delete pMyBlock;  //釋放 
                if(pPreBlock)
                    pPreBlock->pNext = NULL;  //設置上一塊的pNext指向NULL 
                else
                    pBlock = NULL;
            }
                
        }
    }
}
// ------------------------------------------------------------------------- 
// $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

“池化技術”漫談 - 線程池，內存池，連接池……

“池化技術”漫談 - 線程池，內存池，連接池……

Ｃ＃中窗體之間的數據傳遞

馮.諾伊曼結構VS哈佛結構

一些軟件設計的原則

內存泄露檢查

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結