線程池是一種多線程處理形式，大多用于高并發服務器上，它能合理有效的利用高并發服務器上的線程資源;線程與進程用于處理各項分支子功能，我們通常的操作是：接收消息 ==> 消息分類 ==> 線程創建 ==> 傳遞消息到子線程 ==> 線程分離 ==> 在子線程中執行任務 ==> 任務結束退出;

[[317565]]

對大多數小型局域網的通信來說，上述方法足夠滿足需求;但當我們的通信范圍擴大到廣域網或大型局域網通信中時，我們將面臨大量消息頻繁請求服務器;在這種情況下，創建與銷毀線程都已經成為一種奢侈的開銷，特別對于嵌入式服務器來說更應保證內存資源的合理利用;

因此，線程池技術應運而生;線程池允許一個線程可以多次復用，且每次復用的線程內部的消息處理可以不相同，將創建與銷毀的開銷省去而不必來一個請求開一個線程;

結構講解：

線程池是一個抽象的概念，其內部由任務隊列，一堆線程，管理者線程組成;

我們將以上圖為例，實現一個最基礎的線程池，接下來將分部分依次講解;講解順序為：1.線程池總體結構 2.線程數組 3.任務隊列 4.管理者線程 5.使用線程池接口的例子

一、線程池總體結構

這里講解線程池在邏輯上的結構體;看下方代碼，該結構體threadpool_t中包含線程池狀態信息，任務隊列信息以及多線程操作中的互斥鎖;在任務結構體中包含了一個可以放置多種不同任務函數的函數指針，一個傳入該任務函數的void*類型的參數;

注意：在使用時需要將你的消息分類處理函數裝入任務的(*function);然后放置到任務隊列并通知空閑線程;

線程池狀態信息：描述當前線程池的基本信息，如是否開啟、最小線程數、最大線程數、存活線程數、忙線程數、待銷毀線程數等… …

任務隊列信息：描述當前任務隊列基本信息，如最大任務數、隊列不為滿條件變量、隊列不為空條件變量等… …

多線程互斥鎖：保證在同一時間點上只有一個線程在任務隊列中取任務并修改任務隊列信息、修改線程池信息;

函數指針：在打包消息階段，將分類后的消息處理函數放在(*function);

void*類型參數：用于傳遞消息處理函數需要的信息;

/*任務*/ 
typedef struct { 
void *(*function)(void *); 
void *arg; 
} threadpool_task_t; 
/*線程池管理*/ 
struct threadpool_t{ 
pthread_mutex_t lock; /* 鎖住整個結構體 */ 
pthread_mutex_t thread_counter; /* 用于使用忙線程數時的鎖 */ 
pthread_cond_t queue_not_full; /* 條件變量，任務隊列不為滿 */ 
pthread_cond_t queue_not_empty; /* 任務隊列不為空 */ 
pthread_t *threads; /* 存放線程的tid,實際上就是管理了線 數組 */ 
pthread_t admin_tid; /* 管理者線程tid */ 
threadpool_task_t *task_queue; /* 任務隊列 */ 
/*線程池信息*/ 
int min_thr_num; /* 線程池中最小線程數 */ 
int max_thr_num; /* 線程池中最大線程數 */ 
int live_thr_num; /* 線程池中存活的線程數 */ 
int busy_thr_num; /* 忙線程，正在工作的線程 */ 
int wait_exit_thr_num; /* 需要銷毀的線程數 */ 
/*任務隊列信息*/ 
int queue_front; /* 隊頭 */ 
int queue_rear; /* 隊尾 */ 
int queue_size; 
/* 存在的任務數 */ 
int queue_max_size; /* 隊列能容納的最大任務數 */ 
/*線程池狀態*/ 
int shutdown; /* true為關閉 */ 
}; 
**/*創建線程池*/** 
threadpool_t * 
threadpool_create(int min_thr_num, int max_thr_num, int queue_max_size) 
{ /* 最小線程數 最大線程數 最大任務數*/ 
int i; 
threadpool_t *pool = NULL; 
do 
{ 
/* 線程池空間開辟 */ 
if ((pool=(threadpool_t *)malloc(sizeof(threadpool_t))) == NULL) 
{ 
printf("malloc threadpool false; \n"); 
break; 
} 
/*信息初始化*/ 
pool->min_thr_num = min_thr_num; 
pool->max_thr_num = max_thr_num; 
pool->busy_thr_num = 0; 
pool->live_thr_num = min_thr_num; 
pool->wait_exit_thr_num = 0; 
pool->queue_front = 0; 
pool->queue_rear = 0; 
pool->queue_size = 0; 
pool->queue_max_size = queue_max_size; 
pool->shutdown = false; 
/* 根據最大線程數，給工作線程數組開空間，清0 */ 
pool->threads = (pthread_t *)malloc(sizeof(pthread_t)*max_thr_num); 
if (pool->threads == NULL) 
{ 
printf("malloc threads false;\n"); 
break; 
} 
memset(pool->threads, 0, sizeof(pthread_t)*max_thr_num); 
/* 隊列開空間 */ 
pool->task_queue = 
(threadpool_task_t *)malloc(sizeof(threadpool_task_t)*queue_max_size); 
if (pool->task_queue == NULL) 
{ 
printf("malloc task queue false;\n"); 
break; 
} 
/* 初始化互斥鎖和條件變量 */ 
if ( pthread_mutex_init(&(pool->lock), NULL) != 0 || 
pthread_mutex_init(&(pool->thread_counter), NULL) !=0 || 
pthread_cond_init(&(pool->queue_not_empty), NULL) !=0 || 
pthread_cond_init(&(pool->queue_not_full), NULL) !=0) 
{ 
printf("init lock or cond false;\n"); 
break; 
} 
/* 啟動min_thr_num個工作線程 */ 
for (i=0; i<min_thr_num; i++) 
{ 
/* pool指向當前線程池 threadpool_thread函數在后面講解 */ 
pthread_create(&(pool->threads[i]), NULL, threadpool_thread, (void *)pool); 
printf("start thread 0x%x... \n", (unsigned int)pool->threads[i]); 
} 
/* 管理者線程 admin_thread函數在后面講解 */ 
pthread_create(&(pool->admin_tid), NULL, admin_thread, (void *)pool); 
return pool; 
} while(0); 
/* 釋放pool的空間 */ 
threadpool_free(pool); 
return NULL; 
} 

二、線程數組

線程數組實際上是在線程池初始化時開辟的一段存放一堆線程tid的空間，在邏輯上形成一個池，里面放置著提前創建的線程;這段空間中包含了正在工作的線程，等待工作的線程(空閑線程)，等待被銷毀的線程，申明但沒有初始化的線程空間;

/*工作線程*/ 
void * 
threadpool_thread(void *threadpool) 
{ 
threadpool_t *pool = (threadpool_t *)threadpool; 
threadpool_task_t task; 
while (true) 
{ 
pthread_mutex_lock(&(pool->lock)); 
/* 無任務則阻塞在 “任務隊列不為空” 上，有任務則跳出 */ 
while ((pool->queue_size == 0) && (!pool->shutdown)) 
{ 
printf("thread 0x%x is waiting \n", (unsigned int)pthread_self()); 
pthread_cond_wait(&(pool->queue_not_empty), &(pool->lock)); 
/* 判斷是否需要清除線程,自殺功能 */ 
if (pool->wait_exit_thr_num > 0) 
{ 
pool->wait_exit_thr_num--; 
/* 判斷線程池中的線程數是否大于最小線程數，是則結束當前線程 */ 
if (pool->live_thr_num > pool->min_thr_num) 
{ 
printf("thread 0x%x is exiting \n", (unsigned int)pthread_self()); 
pool->live_thr_num--; 
pthread_mutex_unlock(&(pool->lock)); 
pthread_exit(NULL);//結束線程 
} 
} 
} 
/* 線程池開關狀態 */ 
if (pool->shutdown) //關閉線程池 
{ 
pthread_mutex_unlock(&(pool->lock)); 
printf("thread 0x%x is exiting \n", (unsigned int)pthread_self()); 
pthread_exit(NULL); //線程自己結束自己 
} 
//否則該線程可以拿出任務 
task.function = pool->task_queue[pool->queue_front].function; //出隊操作 
task.arg = pool->task_queue[pool->queue_front].arg; 
pool->queue_front = (pool->queue_front + 1) % pool->queue_max_size; //環型結構 
pool->queue_size--; 
//通知可以添加新任務 
pthread_cond_broadcast(&(pool->queue_not_full)); 
//釋放線程鎖 
pthread_mutex_unlock(&(pool->lock)); 
//執行剛才取出的任務 
printf("thread 0x%x start working \n", (unsigned int)pthread_self()); 
pthread_mutex_lock(&(pool->thread_counter)); //鎖住忙線程變量 
pool->busy_thr_num++; 
pthread_mutex_unlock(&(pool->thread_counter)); 
(*(task.function))(task.arg); //執行任務 
//任務結束處理 
printf("thread 0x%x end working \n", (unsigned int)pthread_self()); 
pthread_mutex_lock(&(pool->thread_counter)); 
pool->busy_thr_num--; 
pthread_mutex_unlock(&(pool->thread_counter)); 
} 
pthread_exit(NULL); 
} 

三、任務隊列

任務隊列的存在形式與線程數組相似;在線程池初始化時根據傳入的最大任務數開辟空間;當服務器前方后請求到來后，分類并打包消息成為任務，將任務放入任務隊列并通知空閑線程來取;不同之處在于任務隊列有明顯的先后順序，先進先出;而線程數組中的線程則是一個競爭關系去拿到互斥鎖爭取任務;

/*向線程池的任務隊列中添加一個任務*/ 
int 
threadpool_add_task(threadpool_t *pool, void *(*function)(void *arg), void *arg) 
{ 
pthread_mutex_lock(&(pool->lock)); 
/*如果隊列滿了,調用wait阻塞*/ 
while ((pool->queue_size == pool->queue_max_size) && (!pool->shutdown)) 
pthread_cond_wait(&(pool->queue_not_full), &(pool->lock)); 
/*如果線程池處于關閉狀態*/ 
if (pool->shutdown) 
{ 
pthread_mutex_unlock(&(pool->lock)); 
return -1; 
} 
/*清空工作線程的回調函數的參數arg*/ 
if (pool->task_queue[pool->queue_rear].arg != NULL) 
{ 
free(pool->task_queue[pool->queue_rear].arg); 
pool->task_queue[pool->queue_rear].arg = NULL; 
} 
/*添加任務到任務隊列*/ 
pool->task_queue[pool->queue_rear].function = function; 
pool->task_queue[pool->queue_rear].arg = arg; 
pool->queue_rear = (pool->queue_rear + 1) % pool->queue_max_size; /* 邏輯環 */ 
pool->queue_size++; 
/*添加完任務后,隊列就不為空了,喚醒線程池中的一個線程*/ 
pthread_cond_signal(&(pool->queue_not_empty)); 
pthread_mutex_unlock(&(pool->lock)); 
return 0; 
} 

四、管理者線程

作為線程池的管理者，該線程的主要功能包括：檢查線程池內線程的存活狀態，工作狀態;負責根據服務器當前的請求狀態去動態的增加或刪除線程，保證線程池中的線程數量維持在一個合理高效的平衡上;

說到底，它就是一個單獨的線程，定時的去檢查，根據我們的一個維持平衡算法去增刪線程;

/*管理線程*/ 
void * 
admin_thread(void *threadpool) 
{ 
int i; 
threadpool_t *pool = (threadpool_t *)threadpool; 
while (!pool->shutdown) 
{ 
printf("admin -----------------\n"); 
sleep(DEFAULT_TIME); /*隔一段時間再管理*/ 
pthread_mutex_lock(&(pool->lock)); /*加鎖*/ 
int queue_size = pool->queue_size; /*任務數*/ 
int live_thr_num = pool->live_thr_num; /*存活的線程數*/ 
pthread_mutex_unlock(&(pool->lock)); /*解鎖*/ 
pthread_mutex_lock(&(pool->thread_counter)); 
int busy_thr_num = pool->busy_thr_num; /*忙線程數*/ 
pthread_mutex_unlock(&(pool->thread_counter)); 
printf("admin busy live -%d--%d-\n", busy_thr_num, live_thr_num); 
/*創建新線程 實際任務數量大于 最小正在等待的任務數量，存活線程數小于最大線程數*/ 
if (queue_size >= MIN_WAIT_TASK_NUM && live_thr_num <= pool->max_thr_num) 
{ 
printf("admin add-----------\n"); 
pthread_mutex_lock(&(pool->lock)); 
int add=0; 
/*一次增加 DEFAULT_THREAD_NUM 個線程*/ 
for (i=0; i<pool->max_thr_num && add<DEFAULT_THREAD_NUM 
&& pool->live_thr_num < pool->max_thr_num; i++) 
{ 
if (pool->threads[i] == 0 || !is_thread_alive(pool->threads[i])) 
{ 
pthread_create(&(pool->threads[i]), NULL, threadpool_thread, (void *)pool); 
add++; 
pool->live_thr_num++; 
printf("new thread -----------------------\n"); 
} 
} 
pthread_mutex_unlock(&(pool->lock)); 
} 
/*銷毀多余的線程 忙線程x2 都小于 存活線程，并且存活的大于最小線程數*/ 
if ((busy_thr_num*2) < live_thr_num && live_thr_num > pool->min_thr_num) 
{ 
// printf("admin busy --%d--%d----\n", busy_thr_num, live_thr_num); 
/*一次銷毀DEFAULT_THREAD_NUM個線程*/ 
pthread_mutex_lock(&(pool->lock)); 
pool->wait_exit_thr_num = DEFAULT_THREAD_NUM; 
pthread_mutex_unlock(&(pool->lock)); 
for (i=0; i<DEFAULT_THREAD_NUM; i++) 
{ 
//通知正在處于空閑的線程，自殺 
pthread_cond_signal(&(pool->queue_not_empty)); 
printf("admin cler --\n"); 
} 
} 
} 
return NULL; 
/*線程是否存活*/ 
int 
is_thread_alive(pthread_t tid) 
{ 
int kill_rc = pthread_kill(tid, 0); //發送0號信號，測試是否存活 
if (kill_rc == ESRCH) //線程不存在 
{ 
return false; 
} 
return true; 
} 

五、釋放

/*釋放線程池*/ 
int 
threadpool_free(threadpool_t *pool) 
{ 
if (pool == NULL) 
return -1; 
if (pool->task_queue) 
free(pool->task_queue); 
if (pool->threads) 
{ 
free(pool->threads); 
pthread_mutex_lock(&(pool->lock)); /*先鎖住再銷毀*/ 
pthread_mutex_destroy(&(pool->lock)); 
pthread_mutex_lock(&(pool->thread_counter)); 
pthread_mutex_destroy(&(pool->thread_counter)); 
pthread_cond_destroy(&(pool->queue_not_empty)); 
pthread_cond_destroy(&(pool->queue_not_full)); 
} 
free(pool); 
pool = NULL; 
return 0; 
} 
/*銷毀線程池*/ 
int 
threadpool_destroy(threadpool_t *pool) 
{ 
int i; 
if (pool == NULL) 
{ 
return -1; 
} 
pool->shutdown = true; 
/*銷毀管理者線程*/ 
pthread_join(pool->admin_tid, NULL); 
//通知所有線程去自殺(在自己領任務的過程中) 
for (i=0; i<pool->live_thr_num; i++) 
{ 
pthread_cond_broadcast(&(pool->queue_not_empty)); 
} 
/*等待線程結束 先是pthread_exit 然后等待其結束*/ 
for (i=0; i<pool->live_thr_num; i++) 
{ 
pthread_join(pool->threads[i], NULL); 
} 
threadpool_free(pool); 
return 0; 
} 

六、接口

/* 線程池初始化，其管理者線程及工作線程都會啟動 */ 
threadpool_t *thp = threadpool_create(10, 100, 100); 
printf("threadpool init ... ... \n"); 
/* 接收到任務后添加 */ 
threadpool_add_task(thp, do_work, (void *)p); 
// ... ... 
/* 銷毀 */ 
threadpool_destroy(thp)；