執行緒池介紹

• 執行緒池允許一個執行緒可以多次複用，且每次複用的執行緒內部的訊息處理可以不相同，將建立與銷燬的開銷省去而不必來一個請求開一個執行緒；簡單來說就是有一堆已經建立好的執行緒（最大數目一定），初始時他們都處於空閒狀態，當有新的任務進來，從執行緒池中取出一個空閒的執行緒處理任務，然後當任務處理完成之後，該執行緒被重新放回到執行緒池中，供其他的任務使用，當執行緒池中的執行緒都在處理任務時，就沒有空閒執行緒供使用，此時，若有新的任務產生，只能等待執行緒池中有執行緒結束任務空閒才能執行，下面是執行緒池的工作原理圖：

應用場景

執行緒池是一種多執行緒處理形式，大多用於高併發伺服器上，它能合理有效的利用高併發伺服器上的執行緒資源；當我們的通訊範圍擴大到廣域網或大型區域網通訊中時，我們將面臨大量訊息頻繁請求伺服器；在這種情況下，建立與銷燬執行緒都已經成為一種奢侈的開銷，特別對於嵌入式伺服器來說更應保證記憶體資源的合理利用；

執行緒池結構

一：執行緒池結構體

typedef struct task
{
    void *(*run)(void *args);  //函式指標，需要執行的任務
    void *arg;              //引數
    struct task *next;      //任務佇列中下一個任務
}task_t;


//下面是執行緒池結構體
typedef struct threadpool
{
    condition_t ready;    //狀態量
    task_t *first;       //任務佇列中第一個任務
    task_t *last;        //任務佇列中最後一個任務
 

    int counter;         //執行緒池中已有執行緒數
    int idle;            //執行緒池中空閒執行緒數
    int max_threads;     //執行緒池最大執行緒數
    int quit;            //是否退出標誌
}threadpool_t;

狀態量：狀態量就是互斥鎖與條件變數，在多執行緒環境中，執行緒池就相當於臨界資源，所以就需要條件變數和互斥鎖來保證每一個執行緒訪問臨界資源的安全高效。
first/last指標：就是執行緒池中維護的任務佇列，在使用執行緒池時，只需要向佇列中新增任務就行，執行緒池中的空閒執行緒會”主動“執行任務。
max_threads：

具體程式碼實現：

用條件變數和互斥鎖封裝的狀態，用來保證執行緒池的安全

condition.h

#ifndef _CONDITION_H_                                                                                                                                          
#define _CONDITION_H_

#include <pthread.h>

//封裝一個互斥量和條件變數作為狀態
typedef struct condition
{
    pthread_mutex_t pmutex;
    pthread_cond_t pcond;
}condition_t;

//對狀態的操作函式
int condition_init(condition_t *cond);
int condition_lock(condition_t *cond);
int condition_unlock(condition_t *cond);
int condition_wait(condition_t *cond);
int condition_timedwait(condition_t *cond, const struct timespec *abstime);
int condition_signal(condition_t* cond);
int condition_broadcast(condition_t *cond);
int condition_destroy(condition_t *cond);

#endif

condition.c

#include "condition.h"                                                                                                                                                                                                                        

//初始化
int condition_init(condition_t *cond)
{
    int status;
    if((status = pthread_mutex_init(&cond->pmutex, NULL)))
        return status;

    if((status = pthread_cond_init(&cond->pcond, NULL)))
        return status;

    return 0;
}

//加鎖
int condition_lock(condition_t *cond)
{
    return pthread_mutex_lock(&cond->pmutex);
}

//解鎖
int condition_unlock(condition_t *cond)
{
    return pthread_mutex_unlock(&cond->pmutex);
}

//等待
int condition_wait(condition_t *cond)
{
    return pthread_cond_wait(&cond->pcond, &cond->pmutex);
}

//固定時間等待
int condition_timedwait(condition_t *cond, const struct timespec *abstime)
{
    return pthread_cond_timedwait(&cond->pcond, &cond->pmutex, abstime);
}

//喚醒一個睡眠執行緒
int condition_signal(condition_t* cond)
{
    return pthread_cond_signal(&cond->pcond);
}

//喚醒所有睡眠執行緒
int condition_broadcast(condition_t *cond)
{
    return pthread_cond_broadcast(&cond->pcond);
}

//銷燬互斥鎖和條件變數
int condition_destroy(condition_t *cond)
{
    int status;
    if((status = pthread_mutex_destroy(&cond->pmutex)))
        return status;

    if((status = pthread_cond_destroy(&cond->pcond)))
        return status;

    return 0;
}

執行緒池threadpool.h

#ifndef _THREAD_POOL_H_                                                                                                                                                                                                                       
#define _THREAD_POOL_H_

//需要引入狀態的標頭檔案--條件變數和互斥鎖
#include "condition.h"

//封裝執行緒池中的物件需要執行的任務物件
typedef struct task
{
    void *(*run)(void *args);  //函式指標，需要執行的任務
    void *arg;              //引數
    struct task *next;      //任務佇列中下一個任務
}task_t;


//下面是執行緒池結構體
typedef struct threadpool
{
    condition_t ready;    //狀態量
    task_t *first;       //任務佇列中第一個任務
    task_t *last;        //任務佇列中最後一個任務
    int counter;         //執行緒池中已有執行緒數
    int idle;            //執行緒池中空閒執行緒數
    int max_threads;     //執行緒池最大執行緒數
    int quit;            //是否退出標誌 1/0
}threadpool_t;


//執行緒池初始化
void threadpool_init(threadpool_t *pool, int idle_threads, int max_threads);

//往執行緒池中加入任務
int threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg);

//摧毀執行緒池
void threadpool_destroy(threadpool_t *pool);

#endif

threadpool.c

#include "threadpool.h"                                                                                                                                                                                                                       
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <time.h>

//執行緒池中建立的執行緒執行
void *thread_routine(void *arg)
{
    struct timespec abstime;//時間結構體
    int timeout;
    printf("thread %d is starting\n", (int)pthread_self());
    threadpool_t *pool = (threadpool_t *)arg;

    //死迴圈使執行緒池中空閒的執行緒可以複用
    while(1)
    {   
        timeout = 0;

        //訪問執行緒池之前需要加鎖
        condition_lock(&pool->ready);

        //空閒
        pool->idle++;

        //任務佇列沒有任務到來並且沒有收到執行緒池銷燬通知, 執行緒阻塞等待(進入這裡面都是空閒執行緒，等待被喚醒)
        while(pool->first == NULL && !pool->quit)
        {   
            printf("thread %d is waiting\n", (int)pthread_self());

            //獲取當前時間，並加上等待時間， 從而設定程序的超時睡眠時間
            clock_gettime(CLOCK_REALTIME, &abstime);  
            abstime.tv_sec += 2;
            int status;
            status = condition_timedwait(&pool->ready, &abstime);  //該函式會解鎖，允許其他執行緒訪問，當被喚醒時，加鎖
            if(status == ETIMEDOUT)
            {   
                printf("thread %d wait timed out\n", (int)pthread_self());
                timeout = 1;
                break;
            }   
        }   

        pool->idle--;
        if(pool->first != NULL)
        {   
            //取出任務佇列最前的任務，移除任務，並執行任務
            task_t *t = pool->first;
            pool->first = t->next;
            //由於任務執行需要消耗時間，先解鎖讓其他執行緒訪問執行緒池
            condition_unlock(&pool->ready);
            //執行任務
            t->run(t->arg);
            //執行完任務釋放記憶體
            free(t);
            //重新加鎖
            condition_lock(&pool->ready);
        }   

        //退出執行緒池--銷燬當前執行緒
        if(pool->quit && pool->first == NULL)
        {
            pool->counter--;//當前工作的執行緒數-1

            //若執行緒池中沒有執行緒，喚醒等待執行緒（主執行緒--銷燬執行緒池的執行緒）全部任務已經完成
            if(pool->counter == 0)
            {
                condition_signal(&pool->ready);
            }
            condition_unlock(&pool->ready);
            break;
        }
        //超時，說明執行緒沒有任務可以執行, 跳出銷燬執行緒
        if(timeout == 1)
        {
            pool->counter--;//當前工作的執行緒數-1
            condition_unlock(&pool->ready);
            break;
        }

        condition_unlock(&pool->ready);
    }

    printf("thread %d is exiting\n", (int)pthread_self());
    return NULL;

}


//執行緒池初始化
void threadpool_init(threadpool_t *pool, int idle_threads, int max_threads)
{

    condition_init(&pool->ready);
    pool->first = NULL;
    pool->last =NULL;
    pool->counter =0;
    pool->idle =0;
    pool->max_threads = max_threads;
    pool->quit =0;

    //建立空閒執行緒
   int i = 0;
   for(; i < idle_threads; i++)
   {
       pthread_t tid;
        pthread_create(&tid, NULL, thread_routine, pool);
        pool->counter++;//已有執行緒數+1
   }

}
//增加一個任務到執行緒池
int threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg)
{
    //產生一個新的任務
    task_t *newtask = (task_t *)malloc(sizeof(task_t));
    newtask->run = run;
    newtask->arg = arg;
    newtask->next=NULL;//新加的任務放在佇列尾端

    //執行緒池的狀態被多個執行緒共享，操作前需要加鎖
    condition_lock(&pool->ready);

    if(pool->first == NULL)//第一個任務加入
    {
        pool->first = newtask;
    }        
    else    
    {
        pool->last->next = newtask;
    }
    pool->last = newtask;  //佇列尾指向新加入的執行緒

    //執行緒池中有執行緒空閒，喚醒處於等待狀態的執行緒(因為在等待期間會釋放互斥鎖)
    if(pool->idle > 0)
    {
        condition_signal(&pool->ready);
    }
    //當前執行緒池中執行緒個數沒有達到設定的最大值，建立一個新的執行緒
    else if(pool->counter < pool->max_threads)
    {
        pthread_t tid;
        pthread_create(&tid, NULL, thread_routine, pool);
        pool->counter++;
    }
    else
    {
        condition_unlock(&pool->ready);
        return -1;
    }
    //結束，訪問
    condition_unlock(&pool->ready);
    return 0;
}

//執行緒池銷燬
void threadpool_destroy(threadpool_t *pool)
{
    //如果已經呼叫銷燬，直接返回
    if(pool->quit)
    {
        return;
    }
    //加鎖
    condition_lock(&pool->ready);                                                                                                                                                                                                             
    //設定銷燬標記為1
    pool->quit = 1;
    //執行緒池中執行緒個數大於0
  if(pool->counter > 0)
    {
        //對於等待的執行緒，傳送訊號喚醒
        if(pool->idle > 0)
        {
            condition_broadcast(&pool->ready);
        }
        //正在執行任務的執行緒，等待他們結束任務
        while(pool->counter)
        {
            condition_wait(&pool->ready);
        }
    }
    condition_unlock(&pool->ready);
    condition_destroy(&pool->ready);
}                    

測試程式碼test.c

#include <stdio.h>                                                                                                                                                                                                                          
  #include "threadpool.h"
  #include <unistd.h>
  #include <stdlib.h>
  #include <stdio.h>

  void* mytask(void *arg)
  {
      printf("thread %d is working on task %d\n", (int)pthread_self(),(int)arg);
      sleep(1);
      return NULL;

  }
  //測試程式碼
  int main(void)
  {
      threadpool_t pool;
      //初始化執行緒池，建立2個空閒執行緒，最多5個執行緒
      threadpool_init(&pool, 2, 5); 
      int i;
      //建立十個任務
      for(i=0; i < 10; i++)
      {   
       threadpool_add_task(&pool, mytask, (void*)i);

      }   
      threadpool_destroy(&pool);
      return 0;
  }

仔細研究下測試程式碼的執行流程