LINUX下的简单线程池

    前言

    任何一种设计方式的引入都会带来额外的开支，是否使用，取决于能带来多大的好处和能带来多大的坏处，好处与坏处包括程序的性能、代码的可读性、代码的可维护性、程序的开发效率等。

    线程池适用场合：任务比较多，需要拉起大量线程来处理；任务的处理时间相对比较短，按照线程的周期T1（创建阶段）、T2（执行阶段）、T3（销毁阶段）来算，执行阶段仅占用较少时间。

    简单的线程池通常有以下功能：预创建一定数量的线程；管理线程任务，当工作线程没有事情可做时休眠自己；销毁线程池。

    复杂一些的线程池有额外的调节功能：管理线程池的上限；动态调节工作线程数量，当大量工作请求到来时增加工作线程，工作请求较少时销毁部分线程。

    内容部分

    这次实现的是一个简单的线程池模型。

    首先是线程池的头文件定义：

 1 #include<unistd.h>
 2 #include<stdlib.h>
 3 #include<iostream>
 4 #include<string>
 5 #include<string.h>
 6 #include<queue>
 7 #include<errno.h>
 8 #include<pthread.h>
 9 using namespace std;
10 
11 struct  thread_work
12 {   
13     void* (*routine)(void*);
14     void* arg;
15 };
16 
17 struct thread_pool
18 {   
19     bool ShutDown;
20     unsigned int iMaxThreadNum;
21     pthread_mutex_t pool_mutex;
22     pthread_cond_t pool_cond;
23     queue<pthread_t> Pth_IdQueue;
24     queue<thread_work> Pth_workQueue;
25 };
26 
27 thread_pool* thread_pool_create(int iThreadNum);
28 void thread_pool_destroy(thread_pool* thpool);
29 int thread_pool_add_task(thread_pool* thpool, void*(*routine)(void*), void* arg);
30 void* thread_routine(void* arg);

    下面是线程池的实现：

  1 #include "ThreadPool.h"
  2 
  3 thread_pool* thread_pool_create(int iThreadMaxNum)
  4 {
  5     int iRet = 0;
  6     thread_pool* pool = new thread_pool;
  7     if(NULL == pool)
  8     {
  9         cout << "new thread_pool failed! procedure exit" << endl;
 10         return NULL;
 11     }
 12     pool->iMaxThreadNum = iThreadMaxNum;
 13     pool->ShutDown = false;
 14     if((iRet=pthread_mutex_init(&pool->pool_mutex, NULL)) != 0)
 15     {
 16         cout << __FUNCTION__ << "thread_pool init failed! error: " << strerror(iRet)  << endl;
 17         delete pool;
 18         return NULL;
 19     }
 20     if((iRet=pthread_cond_init(&pool->pool_cond, NULL)) != 0)
 21     {
 22         cout << __FUNCTION__ << "thread_cond init failed! error: " << strerror(iRet) << endl;
 23         delete pool;
 24         return NULL;
 25     }
 26     
 27     for(int i = 0; i < iThreadMaxNum; i++)
 28     {
 29         pthread_t thid = 0;
 30         if((iRet=pthread_create(&thid, NULL, thread_routine, (void*)pool)) != 0)
 31         {
 32             cout << __FUNCTION__ << " pthread_create failed, error: " << strerror(iRet) << endl;
 33             delete pool;
 34             return NULL;
 35         }
 36         else
 37         {
 38             pool->Pth_IdQueue.push(thid);
 39         }
 40     }
 41     return pool;
 42 }
 43 
 44 int thread_pool_add_task(thread_pool* thpool, void*(*routine)(void*), void* arg)
 45 {
 46     if(routine == NULL  || thpool == NULL)
 47         return -1;
 48     thread_work temp;
 49     temp.routine = routine;
 50     temp.arg = arg;
 51     pthread_mutex_lock(&(thpool->pool_mutex));
 52     thpool->Pth_workQueue.push(temp);
 53     pthread_mutex_unlock(&(thpool->pool_mutex));
 54     pthread_cond_signal(&(thpool->pool_cond));
 55     return 0;
 56 }
 57 
 58 void thread_pool_destroy(thread_pool* thpool)
 59 {
 60     if(thpool == NULL)
 61         return;
 62     pthread_mutex_lock(&(thpool->pool_mutex));
 63     thpool->ShutDown = true;
 64     while(!thpool->Pth_workQueue.empty())
 65     {
 66         thpool->Pth_workQueue.pop();
 67     }
 68     pthread_cond_broadcast(&(thpool->pool_cond));
 69     pthread_mutex_unlock(&(thpool->pool_mutex));
 70     while(!thpool->Pth_IdQueue.empty())
 71     {
 72         pthread_join(thpool->Pth_IdQueue.front(), NULL);
 73         thpool->Pth_IdQueue.pop();
 74     }
 75     pthread_mutex_destroy(&(thpool->pool_mutex));
 76     pthread_cond_destroy(&(thpool->pool_cond));
 77     delete thpool;
 78 }
 79 
 80 void* thread_routine(void* pool)
 81 {
 82     if(pool == NULL)
 83     {
 84         cout << "thread_routine params is empty, thread_exit" << endl;
 85         return NULL;
 86     }
 87     while(1)
 88     {
 89         thread_pool* p = (thread_pool*)pool;
 90         pthread_mutex_lock(&(p->pool_mutex));
 91         while(p->Pth_workQueue.empty() && !p->ShutDown)
 92         {
 93             pthread_cond_wait(&(p->pool_cond), &(p->pool_mutex));
 94         }
 95         if(p->ShutDown)
 96         {
 97             pthread_mutex_unlock(&(p->pool_mutex));
 98             return NULL;
 99         }
100         thread_work work_f;
101         work_f = p->Pth_workQueue.front();
102         p->Pth_workQueue.pop();
103         pthread_mutex_unlock(&(p->pool_mutex));
104         work_f.routine(work_f.arg);
105     }
106 }

    代码都是基础知识，大家应该都能理解。

    下面是一个测试的demo：

 1 #include "ThreadPool.h"
 2 
 3 void* task(void* p)
 4 {
 5     int ptI = *(int*)p;
 6     //cout << "ptr address : " << p << "ptr value : " << ptI << endl;
 7     cout << ptI << endl;
 8     return NULL;
 9 }
10 
11 int main()
12 {
13     struct thread_pool* pool = thread_pool_create(100);
14     int iArg[1000];
15     for(int i = 0; i < 1000; i++)
16     {
17         iArg[i] = i;
18         thread_pool_add_task(pool, task, &iArg[i]);
19         //cout << "thread_pool_add_task id: " << iArg[i] << endl;
20         //cout << __FUNCTION__ << " success, current task id is: " << iArg[i]  << "iArg[" << i << "] address : " << &iArg[i]  << endl;
21     }
22     thread_pool_destroy(pool);    
23 }

    小结

    很简单很好理解的一段代码，我却写了大半天时间，手残党鉴定完毕。