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

 

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

#ifndef _ThreadPool_H_

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

很简洁通用的线程池实现。