转载一份C++线程池的代码,非常实用

  1. #ifndef _ThreadPool_H_
  2. #define _ThreadPool_H_
  3. #pragma warning(disable: 4530)
  4. #pragma warning(disable: 4786)
  5. #include <cassert>
  6. #include <vector>
  7. #include <queue>
  8. #include <windows.h>
  9. using namespace std;
  10. class ThreadJob  //工作基类
  11. {
  12. public:
  13.   //供线程池调用的虚函数
  14.   virtual void DoJob(void *pPara) = 0;
  15. };
  16. class ThreadPool
  17. {
  18. public:
  19.   //dwNum 线程池规模
  20.   ThreadPool(DWORD dwNum = 4) : _lThreadNum(0), _lRunningNum(0) 
  21.   {
  22.     InitializeCriticalSection(&_csThreadVector);
  23.     InitializeCriticalSection(&_csWorkQueue);
  24.     _EventComplete = CreateEvent(0, falsefalse, NULL);
  25.     _EventEnd = CreateEvent(0, truefalse, NULL);
  26.     _SemaphoreCall = CreateSemaphore(0, 0,  0x7FFFFFFF, NULL);
  27.     _SemaphoreDel =  CreateSemaphore(0, 0,  0x7FFFFFFF, NULL);
  28.     assert(_SemaphoreCall != INVALID_HANDLE_VALUE);
  29.     assert(_EventComplete != INVALID_HANDLE_VALUE);
  30.     assert(_EventEnd != INVALID_HANDLE_VALUE);
  31.     assert(_SemaphoreDel != INVALID_HANDLE_VALUE);
  32.     AdjustSize(dwNum <= 0 ? 4 : dwNum);
  33.   }
  34.   ~ThreadPool()
  35.   {
  36.     DeleteCriticalSection(&_csWorkQueue);
  37.     CloseHandle(_EventEnd);
  38.     CloseHandle(_EventComplete);
  39.     CloseHandle(_SemaphoreCall);
  40.     CloseHandle(_SemaphoreDel);
  41.     vector<ThreadItem*>::iterator iter;
  42.     for(iter = _ThreadVector.begin(); iter != _ThreadVector.end(); iter++)
  43.     {
  44.       if(*iter)
  45.         delete *iter;
  46.     }
  47.     DeleteCriticalSection(&_csThreadVector);
  48.   }
  49.   //调整线程池规模
  50.   int AdjustSize(int iNum)
  51.   {
  52.     if(iNum > 0)
  53.     {
  54.       ThreadItem *pNew;
  55.       EnterCriticalSection(&_csThreadVector);
  56.       for(int _i=0; _i<iNum; _i++)
  57.       {
  58.         _ThreadVector.push_back(pNew = new ThreadItem(this)); 
  59.         assert(pNew);
  60.         pNew->_Handle = CreateThread(NULL, 0, DefaultJobProc, pNew, 0, NULL);
  61.         // set priority
  62.         SetThreadPriority(pNew->_Handle, THREAD_PRIORITY_BELOW_NORMAL);
  63.         assert(pNew->_Handle);
  64.       }
  65.       LeaveCriticalSection(&_csThreadVector);
  66.     }
  67.     else
  68.     {
  69.       iNum *= -1;
  70.       ReleaseSemaphore(_SemaphoreDel,  iNum > _lThreadNum ? _lThreadNum : iNum, NULL);
  71.     }
  72.     return (int)_lThreadNum;
  73.   }
  74.   //调用线程池
  75.   void Call(void (*pFunc)(void  *), void *pPara = NULL)
  76.   {
  77.     assert(pFunc);
  78.     EnterCriticalSection(&_csWorkQueue);
  79.     _JobQueue.push(new JobItem(pFunc, pPara));
  80.     LeaveCriticalSection(&_csWorkQueue);
  81.     ReleaseSemaphore(_SemaphoreCall, 1, NULL);
  82.   }
  83.   //调用线程池
  84.   inline void Call(ThreadJob * p, void *pPara = NULL)
  85.   {
  86.     Call(CallProc, new CallProcPara(p, pPara));
  87.   }
  88.   //结束线程池, 并同步等待
  89.   bool EndAndWait(DWORD dwWaitTime = INFINITE)
  90.   {
  91.     SetEvent(_EventEnd);
  92.     return WaitForSingleObject(_EventComplete, dwWaitTime) == WAIT_OBJECT_0;
  93.   }
  94.   //结束线程池
  95.   inline void End()
  96.   {
  97.     SetEvent(_EventEnd);
  98.   }
  99.   inline DWORD Size()
  100.   {
  101.     return (DWORD)_lThreadNum;
  102.   }
  103.   inline DWORD GetRunningSize()
  104.   {
  105.     return (DWORD)_lRunningNum;
  106.   }
  107.   bool IsRunning()
  108.   {
  109.     return _lRunningNum > 0;
  110.   }
  111. protected:
  112.   //工作线程
  113.   static DWORD WINAPI DefaultJobProc(LPVOID lpParameter = NULL)
  114.   {
  115.     ThreadItem *pThread = static_cast<ThreadItem*>(lpParameter);
  116.     assert(pThread);
  117.     ThreadPool *pThreadPoolObj = pThread->_pThis;
  118.     assert(pThreadPoolObj);
  119.     InterlockedIncrement(&pThreadPoolObj->_lThreadNum);
  120.     HANDLE hWaitHandle[3];
  121.     hWaitHandle[0] = pThreadPoolObj->_SemaphoreCall;
  122.     hWaitHandle[1] = pThreadPoolObj->_SemaphoreDel;
  123.     hWaitHandle[2] = pThreadPoolObj->_EventEnd;
  124.     JobItem *pJob;
  125.     bool fHasJob;
  126.     for(;;)
  127.     {
  128.       DWORD wr = WaitForMultipleObjects(3, hWaitHandle, false, INFINITE);
  129.       //响应删除线程信号
  130.       if(wr == WAIT_OBJECT_0 + 1)  
  131.         break;
  132.       //从队列里取得用户作业
  133.       EnterCriticalSection(&pThreadPoolObj->_csWorkQueue);
  134.       if(fHasJob = !pThreadPoolObj->_JobQueue.empty())
  135.       {
  136.         pJob = pThreadPoolObj->_JobQueue.front();
  137.         pThreadPoolObj->_JobQueue.pop();
  138.         assert(pJob);
  139.       }
  140.       LeaveCriticalSection(&pThreadPoolObj->_csWorkQueue);
  141.       //受到结束线程信号 确定是否结束线程(结束线程信号 && 是否还有工作)
  142.       if(wr == WAIT_OBJECT_0 + 2 && !fHasJob)  
  143.         break;
  144.       if(fHasJob && pJob)
  145.       {
  146.         InterlockedIncrement(&pThreadPoolObj->_lRunningNum);
  147.         pThread->_dwLastBeginTime = GetTickCount();
  148.         pThread->_dwCount++;
  149.         pThread->_fIsRunning = true;
  150.         pJob->_pFunc(pJob->_pPara); //运行用户作业
  151.         delete pJob; 
  152.         pThread->_fIsRunning = false;
  153.         InterlockedDecrement(&pThreadPoolObj->_lRunningNum);
  154.       }
  155.     }
  156.     //删除自身结构
  157.     EnterCriticalSection(&pThreadPoolObj->_csThreadVector);
  158.     pThreadPoolObj->_ThreadVector.erase(find(pThreadPoolObj->_ThreadVector.begin(), pThreadPoolObj->_ThreadVector.end(), pThread));
  159.     LeaveCriticalSection(&pThreadPoolObj->_csThreadVector);
  160.     delete pThread;
  161.     InterlockedDecrement(&pThreadPoolObj->_lThreadNum);
  162.     if(!pThreadPoolObj->_lThreadNum)  //所有线程结束
  163.       SetEvent(pThreadPoolObj->_EventComplete);
  164.     return 0;
  165.   }
  166.   //调用用户对象虚函数
  167.   static void CallProc(void *pPara) 
  168.   {
  169.     CallProcPara *cp = static_cast<CallProcPara *>(pPara);
  170.     assert(cp);
  171.     if(cp)
  172.     {
  173.       cp->_pObj->DoJob(cp->_pPara);
  174.       delete cp;
  175.     }
  176.   }
  177.   //用户对象结构
  178.   struct CallProcPara  
  179.   {
  180.     ThreadJob* _pObj;//用户对象 
  181.     void *_pPara;//用户参数
  182.     CallProcPara(ThreadJob* p, void *pPara) : _pObj(p), _pPara(pPara) { };
  183.   };
  184.   //用户函数结构
  185.   struct JobItem 
  186.   {
  187.     void (*_pFunc)(void  *);//函数
  188.     void *_pPara; //参数
  189.     JobItem(void (*pFunc)(void  *) = NULL, void *pPara = NULL) : _pFunc(pFunc), _pPara(pPara) { };
  190.   };
  191.   //线程池中的线程结构
  192.   struct ThreadItem
  193.   {
  194.     HANDLE _Handle; //线程句柄
  195.     ThreadPool *_pThis;  //线程池的指针
  196.     DWORD _dwLastBeginTime; //最后一次运行开始时间
  197.     DWORD _dwCount; //运行次数
  198.     bool _fIsRunning;
  199.     ThreadItem(ThreadPool *pthis) : _pThis(pthis), _Handle(NULL), _dwLastBeginTime(0), _dwCount(0), _fIsRunning(false) { };
  200.     ~ThreadItem()
  201.     {
  202.       if(_Handle)
  203.       {
  204.         CloseHandle(_Handle);
  205.         _Handle = NULL;
  206.       }
  207.     }
  208.   };
  209.   std::queue<JobItem *> _JobQueue;  //工作队列
  210.   std::vector<ThreadItem *>  _ThreadVector; //线程数据
  211.   CRITICAL_SECTION _csThreadVector, _csWorkQueue; //工作队列临界, 线程数据临界
  212.   HANDLE _EventEnd, _EventComplete, _SemaphoreCall, _SemaphoreDel;//结束通知, 完成事件, 工作信号, 删除线程信号
  213.   long _lThreadNum, _lRunningNum; //线程数, 运行的线程数
  214. };
  215. #endif //_ThreadPool_H_
转载自  http://blog.csdn.net/pjchen/archive/2004/11/06/170606.aspx
基本上是拿来就用了,对WIN32 API不熟,但对线程池的逻辑还是比较熟的,认为这个线程池写得很清晰,我拿来用在一个多线程下载的模块中。很实用的东东。
调用方法
void threadfunc(void *p)
{
     YourClass* yourObject = (YourClass*)    p;

 //...
}
 ThreadPool tp;
 for(i=0; i<100; i++)
  tp.Call(threadfunc);

ThreadPool tp(20);//20为初始线程池规模

 tp.Call(threadfunc, lpPara);
     

使用时注意几点:
1.  ThreadJob  没什么用,直接写线程函数吧。 
2. 线程函数(threadfunc)的入口参数void* 可以转成自定义的类型对象,这个对象可以记录下线程运行中的数据,并设置线程当前状态,以此与线程进行交互。
3. 线程池有一个EndAndWait函数,用于让线程池中所有计算正常结束。有时线程池中的一个线程可能要运行很长时间,怎么办?可以通过线程函数threadfunc的入口参数对象来处理,比如:
class YourClass {
  int cmd; // cmd = 1是上线程停止计算,正常退出。
};
threadfunc(void* p) {
  YourClass* yourObject = (YourClass*)p;
  while (true) {
    // do some calculation
    if (yourClass->cmd == 1)
      break;
  }
}
在主线程中设置yourClass->cmd = 1,该线程就会自然结束。
很简洁通用的线程池实现。


你可能感兴趣的:(多线程,C++,工作,object,cmd,作业)