用new、malloc申請記憶體時，由於每次申請的大小不同，最後可能導致會有許多記憶體碎片無法使用，造成記憶體浪費和不好管理的問題。記憶體池則是在真正使用記憶體之前，先申請分配一定數量的、大小相等的記憶體塊留做備用。當有新的記憶體需求時，就從記憶體池中分出一部分記憶體塊，若記憶體塊不夠則繼續申請新的記憶體。這樣做有效的避免了記憶體碎片，提高了記憶體使用效率。

而程序池（執行緒池與程序池的概念基本一致）就引用了記憶體池的思想，由伺服器預先建立一組程序，程序池中所有子程序都執行相同的程式碼，擁有相同的屬性，如：優先順序、PGID（程序組ID）。

當有新的任務來到時，主程序將通過某種方式選擇程序池中的某一個子程序來為之服務。相比於動態建立子程序，選擇一個已經存在的子程序的代價顯得小得多。至於主程序選擇哪個子程序來為新任務服務，則有兩種方法：

主程序使用某種演算法來主動選擇子程序。最簡單、最常用的演算法是隨機演算法和 Round Robin （輪流演算法）。

1. 主程序和所有子程序通過一個共享的工作佇列來同步，子程序都睡眠在該工作佇列上。當有新的任務到來時，主程序將任務新增到工作佇列中。這將喚醒正在等待任務的子程序，不過只有一個子程序將獲得新任務的“接管權”，它可以從工作佇列中取出任務並執行之，而其他子程序將繼續睡眠在工作佇列上。
2. 當選擇好子程序後，主程序還需要使用某種通知機制來告訴目標子程序有新任務需要處理，並傳遞必要的資料。最簡單的方式是，在父程序和子程序之間預先建立好一條管道，然後通過管道來實現所有的程序間通訊。在父執行緒和子執行緒之間傳遞資料就要簡單得多，因為我們可以把這些資料定義為全域性，那麼它們本身就是被所有執行緒共享的。

在使用程序池處理多客戶任務時，首先考慮的一個問題是：監聽socket和連線socket是否都由主程序來統一管理。併發模型，其中半同步/半反應堆模式是由主程序統一管理這兩種socket的。而高效的半同步/半非同步和領導者/追隨者模式，則是由主程序管理所有監聽socket，而各個子程序分別管理屬於自己的連線socket的。對於前一種情況，主程序接受新的連線以得到連線socket，然後它需要將該socket傳遞給子程序（對於執行緒池而言，父執行緒將socket傳遞給子執行緒是很簡單的。因為他們可以很容易地共享該socket。但對於程序池而言，必須通過管道傳輸）。後一種情況的靈活性更大一些，因為子程序可以自己呼叫accept來接受新的連線，這樣該父程序就無須向子程序傳遞socket。而只需要簡單地通知一聲：“我檢測到新的連線，你來接受它。

常連線，即一個客戶的多次請求可以複用一個TCP連線。那麼，在設計程序池時還需要考慮：一個客戶連線上的所有任務是否始終由一個子程序來處理。如果說客戶任務是無狀態的，那麼我們可以考慮使用不同的程序為該客戶不同請求服務。

但如果客戶任務是存在上下文關係的，則最好一直用同一個程序來為之服務，否則實現起來比較麻煩，因為我們不得不在各個子程序傳遞上下文資料，我們採用epoll的EPOLLONESHOT事件，這一事件能夠確保一個客戶連線在整個生命週期中僅被一個執行緒處理。

執行緒池程式碼：

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <pthread.h>  
#include <assert.h>  

/* 執行緒池裡所有執行和等待的任務都是一個CThread_worker
 * 由於所有任務都在連結串列裡，所以是一個連結串列結構 
*/  
typedef struct worker  
{
    /*回撥函式，任務執行時會呼叫此函式，注意也可宣告成其它形式*/  
    void *(*process) (void *arg);  
    void *arg;/*回撥函式的引數*/  
    struct worker *next;                
} CThread_worker;  
/*執行緒池結構*/  
typedef struct  
{
    pthread_mutex_t queue_lock;  
    pthread_cond_t queue_ready;  
    /*連結串列結構，執行緒池中所有等待任務*/  
    CThread_worker *queue_head;  
    /*是否銷燬執行緒池*/  
    int shutdown;  
    pthread_t *threadid;  
    /*執行緒池中允許的活動執行緒數目*/  
    int max_thread_num;  
    /*當前等待佇列的任務數目*/  
    int cur_queue_size;  
} CThread_pool;  
int pool_add_worker (void *(*process) (void *arg), void *arg);  
void *thread_routine (void *arg);  
//share resource  
static CThread_pool *pool = NULL;  
void  
pool_init (int max_thread_num)  
{
    pool = (CThread_pool *) malloc (sizeof (CThread_pool));          
    pthread_mutex_init (&(pool->queue_lock), NULL);  
    pthread_cond_init (&(pool->queue_ready), NULL);  
    pool->queue_head = NULL;                      
    pool->max_thread_num = max_thread_num;  
    pool->cur_queue_size = 0;  
    pool->shutdown = 0;  
    pool->threadid = (pthread_t *) malloc (max_thread_num * sizeof (pthread_t));  
    int i = 0;  
    for (i = 0; i < max_thread_num; i++)  
    {
        pthread_create (&(pool->threadid[i]), NULL, thread_routine,NULL);
    }  
}  
/*向執行緒池中加入任務*/  
int pool_add_worker (void *(*process) (void *arg), void *arg)  
{
    /*構造一個新任務*/  
    CThread_worker *newworker = (CThread_worker *) malloc (sizeof (CThread_worker));  
    newworker->process = process;
    newworker->arg = arg;  
    newworker->next = NULL;/*別忘置空*/
    pthread_mutex_lock (&(pool->queue_lock));  
    /*將任務加入到等待佇列中*/  
    CThread_worker *member = pool->queue_head;  
    if (member != NULL)  
    {
        while (member->next != NULL)  
            member = member->next;  
        member->next = newworker;  
    }  
    else  
    {
        pool->queue_head = newworker;  
    }  
    assert (pool->queue_head != NULL);  
    pool->cur_queue_size++;  
    pthread_mutex_unlock (&(pool->queue_lock));  
    /*好了，等待佇列中有任務了，喚醒一個等待執行緒； 
     * 注意如果所有執行緒都在忙碌，這句沒有任何作用*/  
    pthread_cond_signal (&(pool->queue_ready));  
    return 0;  
}
/*銷燬執行緒池，等待佇列中的任務不會再被執行，但是正在執行的執行緒會一直 
 * 把任務執行完後再退出*/  
int pool_destroy ()  
{
    if (pool->shutdown)  
        return -1;/*防止兩次呼叫*/  
    pool->shutdown = 1; 
    /*喚醒所有等待執行緒，執行緒池要銷燬了*/  
    pthread_cond_broadcast (&(pool->queue_ready));  
    /*阻塞等待執行緒退出，否則就成殭屍了*/  
    int i;  
    for (i = 0; i < pool->max_thread_num; i++)  
        pthread_join (pool->threadid[i], NULL);  
    free (pool->threadid);  
    /*銷燬等待佇列*/  
    CThread_worker *head = NULL;  
    while (pool->queue_head != NULL)  
    {
        head = pool->queue_head;
        pool->queue_head = pool->queue_head->next;
        free (head);
    }  
    /*條件變數和互斥量也別忘了銷燬*/  
    pthread_mutex_destroy(&(pool->queue_lock));  
    pthread_cond_destroy(&(pool->queue_ready));  
    free (pool);  
    /*銷燬後指標置空是個好習慣*/  
    pool=NULL;  
    return 0;  
}  
void *thread_routine (void *arg)  
{
    printf ("starting thread 0x%x\n", pthread_self ());  
    while (1)  
    {
        pthread_mutex_lock (&(pool->queue_lock));  
        /*如果等待佇列為0並且不銷燬執行緒池，則處於阻塞狀態; 注意 
         * pthread_cond_wait是一個原子操作，等待前會解鎖，喚醒後會加鎖*/
        while (pool->cur_queue_size == 0 && !pool->shutdown)  
        {
            printf ("thread 0x%x is waiting\n", pthread_self ());  
            pthread_cond_wait (&(pool->queue_ready), &(pool->queue_lock));
        }                                                           
        /*執行緒池要銷燬了*/  
        if (pool->shutdown)  
        {
            /*遇到break,continue,return等跳轉語句，千萬不要忘記先解鎖*/  
            pthread_mutex_unlock (&(pool->queue_lock));  
            printf ("thread 0x%x will exit\n", pthread_self ());  
            pthread_exit (NULL);  
        }  
        printf ("thread 0x%x is starting to work\n", pthread_self ());  
        /*assert是除錯的好幫手*/  
        assert (pool->cur_queue_size != 0);  
        assert (pool->queue_head != NULL);  
        /*等待佇列長度減去1，並取出連結串列中的頭元素*/  
        pool->cur_queue_size--; 
        CThread_worker *worker = pool->queue_head;  
        pool->queue_head = worker->next;  
        pthread_mutex_unlock (&(pool->queue_lock));
        /*呼叫回撥函式，執行任務*/  
        (*(worker->process)) (worker->arg);  
        free (worker);  
        worker = NULL;  
    }  
    /*這一句應該是不可達的*/  
    pthread_exit (NULL);  
}  
//    下面是測試程式碼  
void *myprocess (void *arg)  
{
    printf ("threadid is 0x%x, working on task %d\n", pthread_self (),*(int *) arg);  
    sleep (1);/*休息一秒，延長任務的執行時間*/  
    return NULL;  
}  
int main (int argc, char **argv)  
{
    pool_init (3);/*執行緒池中最多三個活動執行緒*/  
    /*連續向池中投入10個任務*/
    int *workingnum = (int *) malloc (sizeof (int) * 10);
    int i;  
    for (i = 0; i < 10; i++)  
    {
        workingnum[i] = i;
        pool_add_worker (myprocess, &workingnum[i]);  
    }  
    /*等待所有任務完成*/  
    sleep (5);  
    /*銷燬執行緒池*/  
    pool_destroy ();  
    free (workingnum);  
    return 0;  
}