c++实现线程池

   线程池：简单地说，线程池 就是预先创建好一批线程，方便、快速地处理收到的业务。比起传统的到来一个任务，即时创建一个线程来处理，节省了线程的创建和回收的开销，响应更快，效率更高。

在linux中，使用的是posix线程库，首先介绍几个常用的函数：
1 线程的创建和取消函数
  pthread_create 创建线程
  pthread_join  等待线程结束
  pthread_cancel  取消线程

2 线程同步函数

  pthread_mutex_lock
  pthread_mutex_unlock  锁

  pthread_cond_signal
  pthread_cond_wait  信号量

线程池的实现：
   线程池的实现主要分为三部分，线程的创建、添加任务到线程池中、工作线程从任务队列中取出任务进行处理。
主要有两个类来实现，CTask,CThreadPool

/**
执行任务的类，设置任务数据并执行
**/
C++代码

   class CTask 
    { 
     protected: 
        string m_strTaskName;  //任务的名称 
        void* m_ptrData;       //要执行的任务的具体数据 
     public: 
        CTask(){} 
        CTask(string taskName) 
          { 
            this->m_strTaskName = taskName; 
            m_ptrData = NULL; 
          } 
        virtual int Run()= 0; 
        void SetData(void* data);    //设置任务数据 
     }; 



    任务类是个虚类，所有的任务要从CTask类中继承 ，实现run接口，run接口中需要实现的就是具体解析任务的逻辑。m_ptrData是指向任务数据的指针，可以是简单数据类型，也可以是自定义的复杂数据类型。

 

线程池类

/**
线程池
**/
C++代码

    class CThreadPool 
    { 
    private: 
     vector<CTask*> m_vecTaskList;         //任务列表 
     int m_iThreadNum;                            //线程池中启动的线程数            
     static vector<pthread_t> m_vecIdleThread;   //当前空闲的线程集合 
     static vector<pthread_t> m_vecBusyThread;   //当前正在执行的线程集合 
     static pthread_mutex_t m_pthreadMutex;    //线程同步锁 
     static pthread_cond_t m_pthreadCond;    //线程同步的条件变量 
   protected: 
    static void* ThreadFunc(void * threadData); //新线程的线程函数 
    static int MoveToIdle(pthread_t tid);   //线程执行结束后，把自己放入到空闲线程中 
    static int MoveToBusy(pthread_t tid);   //移入到忙碌线程中去 
    int Create();          //创建所有的线程 
   public: 
    CThreadPool(int threadNum); 
    int AddTask(CTask *task);      //把任务添加到线程池中 
    int StopAll(); 
   }; 

     当线程池对象创建后，启动一批线程，并把所有的线程放入空闲列表中，当有任务达时.某一个线程取出任务并进行处理。

线程之间的同步用线程锁和条件变量。
这个类的对外接口有两个：
   1.AddTask函数把任务添加到线程池的任务列表中，并通知线程进行处理。当任务到到时，把任务放入m_vecTaskList任务列表中，并用pthread_cond_signal唤醒一个线程进行处理。

   2.StopAll函数停止所有的线程

Cpp代码

   CThread.h
   #ifndef __CTHREAD 
   #define __CTHREAD 
   #include <vector> 
   #include <string> 
   #include <pthread.h> 
    
   using namespace std; 
    
   /**
   执行任务的类，设置任务数据并执行
   **/ 
   class CTask 
   { 
    protected: 
      string m_strTaskName;  //任务的名称 
      void* m_ptrData;       //要执行的任务的具体数据 
    public: 
      CTask(){} 
      CTask(string taskName) 
        { 
           this->m_strTaskName = taskName; 
           m_ptrData = NULL; 
        } 
      virtual int Run()= 0; 
      void SetData(void* data);    //设置任务数据 
   }; 
    
   /**
   线程池
   **/ 

   class CThreadPool 
   { 
   private: 
      vector<CTask*> m_vecTaskList;         //任务列表 
      int m_iThreadNum;                            //线程池中启动的线程数            
      static vector<pthread_t> m_vecIdleThread;   //当前空闲的线程集合 
      static vector<pthread_t> m_vecBusyThread;   //当前正在执行的线程集合 
      static pthread_mutex_t m_pthreadMutex;    //线程同步锁 
      static pthread_cond_t m_pthreadCond;    //线程同步的条件变量 
   protected: 
      static void* ThreadFunc(void * threadData); //新线程的线程函数 
      static int MoveToIdle(pthread_t tid);//线程执行结束后，把自己放入到空闲线程中 
      static int MoveToBusy(pthread_t tid);   //移入到忙碌线程中去 
      int Create();          //创建所有的线程 
   public: 
      CThreadPool(int threadNum); 
      int AddTask(CTask *task);      //把任务添加到线程池中 
      int StopAll(); 
   };   
   #endif 
 
 CThread.cpp 
       
   #include "CThread.h" 
   #include <string> 
   #include <iostream>   
   using namespace std; 
    
   void CTask::SetData(void * data) 
     { 
        m_ptrData = data; 
     } 
    
   vector<pthread_t> CThreadPool::m_vecBusyThread; 
   vector<pthread_t> CThreadPool::m_vecIdleThread; 
   pthread_mutex_t CThreadPool::m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER; 
   pthread_cond_t CThreadPool::m_pthreadCond = PTHREAD_COND_INITIALIZER; 
    
   CThreadPool::CThreadPool(int threadNum) 
   { 
      this->m_iThreadNum = threadNum; 
      Create(); 
   }
 
  int CThreadPool::MoveToIdle(pthread_t tid) 
   { 
      vector<pthread_t>::iterator busyIter = m_vecBusyThread.begin(); 
      while(busyIter != m_vecBusyThread.end()) 
       { 
         if(tid == *busyIter) 
           { 
             break; 
           } 
       busyIter++; 
       } 
      m_vecBusyThread.erase(busyIter); 
      m_vecIdleThread.push_back(tid); 
      return 0; 
   } 
   
  int CThreadPool::MoveToBusy(pthread_t tid) 
  { 
   vector<pthread_t>::iterator idleIter = m_vecIdleThread.begin(); 
   while(idleIter != m_vecIdleThread.end()) 
    { 
      if(tid == *idleIter) 
       { 
          break; 
       } 
      idleIter++; 
   } 
   m_vecIdleThread.erase(idleIter); 
   m_vecBusyThread.push_back(tid); 
   return 0; 
  } 
 
  void* CThreadPool::ThreadFunc(void * threadData) 
  { 
     pthread_t tid = pthread_self(); 
     while(1) 
      { 
        pthread_mutex_lock(&m_pthreadMutex); 
        pthread_cond_wait(&m_pthreadCond,&m_pthreadMutex); 
        cout << "tid:" << tid << " run" << endl; 
        //get task 
        vector<CTask*>* taskList = (vector<CTask*>*)threadData; 
        vector<CTask*>::iterator iter = taskList->begin(); 
        while(iter != taskList->end()) 
         { 
           MoveToBusy(tid); 
           break; 
         } 
        CTask* task = *iter; 
        taskList->erase(iter); 
        pthread_mutex_unlock(&m_pthreadMutex); 
        cout << "idel thread number:" << CThreadPool::m_vecIdleThread.size() << endl; 
        cout << "busy thread number:" << CThreadPool::m_vecBusyThread.size() << endl; 
        //cout << "task to be run:" << taskList->size() << endl; 
        task->Run(); 
        //cout << "CThread::thread work" << endl; 
        cout << "tid:" << tid << " idle" << endl; 
     
     } 
   return (void*)0; 
  } 
   
  int CThreadPool::AddTask(CTask *task) 
  { 
    this->m_vecTaskList.push_back(task); 
    pthread_cond_signal(&m_pthreadCond); 
    return 0; 
  } 
  int CThreadPool::Create() 
  { 
    for(int i = 0; i < m_iThreadNum;i++) 
    { 
      pthread_t tid = 0; 
      pthread_create(&tid,NULL,ThreadFunc,&m_vecTaskList); 
      m_vecIdleThread.push_back(tid); 
    } 
   return 0; 
  } 
   
  int CThreadPool::StopAll() 
  { 
    vector<pthread_t>::iterator iter = m_vecIdleThread.begin(); 
    while(iter != m_vecIdleThread.end()) 
     { 
       pthread_cancel(*iter); 
       pthread_join(*iter,NULL); 
       iter++; 
     } 
   
    iter = m_vecBusyThread.begin(); 
    while(iter != m_vecBusyThread.end()) 
     { 
       pthread_cancel(*iter); 
       pthread_join(*iter,NULL); 
       iter++; 
     } 
    
    return 0; 
  } 
   
  简单示例： 
  
  ××××××××test.cpp 
   
  #include "CThread.h" 
  #include <iostream> 
   
  using namespace std; 
   
  class CWorkTask: public CTask 
  { 
  public: 
   CWorkTask() 
   {} 
   int Run() 
   { 
    cout << (char*)this->m_ptrData << endl; 
    sleep(10); 
    return 0; 
   } 
  };
 
  int main() 
  { 
   CWorkTask taskObj; 
   char szTmp[] = "this is the first thread running,haha success"; 
   taskObj.SetData((void*)szTmp); 
   CThreadPool threadPool(10); 
   for(int i = 0;i < 11;i++) 
   { 
    threadPool.AddTask(&taskObj); 
   } 
   while(1) 
   { 
    sleep(120); 
   } 
   return 0; 
  }