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, false, false, NULL);
  25. _EventEnd = CreateEvent(0, true, false, 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++线程池的代码，非常实用的更多相关文章

  1. Python中的进程池与线程池(包含代码)

    Python中的进程池与线程池 引入进程池与线程池 使用ProcessPoolExecutor进程池,使用ThreadPoolExecutor 使用shutdown 使用submit同步调用 使用su ...

  2. Java线程池ExecutorService 代码备忘

    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5)创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待 p ...

  3. 线程池的概念&原理和线程池的代码实现

    线程池:一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作, 无需反复创建线程而消耗过多资源.工作原理:可以用一张图来简洁明了说明: 合理利用线程池能够带来三个好处∶1.降低 ...

  4. C++11的简单线程池代码阅读

    这是一个简单的C++11实现的线程池,代码很简单. 原理就是管理一个任务队列和一个工作线程队列. 工作线程不断的从任务队列取任务,然后执行.如果没有任务就等待新任务的到来.添加新任务的时候先添加到任务 ...

  5. .net重启iis线程池和iis站点程序代码【转】

    转:http://www.jb51.net/article/44162.htm 重启站点: 复制代码代码如下:  /// <summary>        /// 根据名字重启站点.(没重 ...

  6. C++代码利用pthread线程池与curl批量下载地图瓦片数据

    项目需求编写的程序,稳定性有待进一步测试. 适用场景:在网络地图上,比如天地图与谷歌地图,用户用鼠标在地图上拉一个矩形框,希望下载该矩形框内某一层级的瓦片数据,并将所有瓦片拼接成一个完整的,包含地理坐 ...

  7. Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)(转)

    转自:http://blog.csdn.net/wuyuxing24/article/details/48758927 一, 背景 先说下我要实现的功能,server端一直在linux平台下面跑,当客 ...

  8. nginx源码分析——线程池

    源码: nginx 1.13.0-release   一.前言      nginx是采用多进程模型,master和worker之间主要通过pipe管道的方式进行通信,多进程的优势就在于各个进程互不影 ...

  9. nginx源码分析线程池详解

    nginx源码分析线程池详解 一.前言     nginx是采用多进程模型,master和worker之间主要通过pipe管道的方式进行通信,多进程的优势就在于各个进程互不影响.但是经常会有人问道,n ...

随机推荐

  1. Servlet与Tomcat

    Web应用不仅局限于展示在服务器上的静态页面,更多的是根据用的请求动态的生成页面信息,还可以从数据库中提取数据,生成页面返回给用户. 第一种方法:遵循HTTP协议实现一个服务器端软件 第二种方法:利用 ...

  2. Struts2配置详解_配置Action

    Struts2的核心功能是action,对于开发人员来说,使用Struts2主要就是编写action,action类通常都要实现com.opensymphony.xwork2.Action接口,并实现 ...

  3. Android——学习：线性布局权重分配

    LinearLayout在Android中被广泛使用,LinearLayout有一个比较重要的属性——android:layout_weight.按照字面理解就是该控件的权重,这个值默认是 零(0). ...

  4. 微博传播数量和传播深度的预测--基于pyspark和某个回归算法

    8-28决定参加一下这个千万条的数据处理任务,因为场景和自己做过的一个回归分析预测差不多,第一天开始在小规模的数据上做准备工作. 第二次大修改版本 date 20160829 星期一¶ 原始数据处理, ...

  5. Python numpy学习笔记（一）

    下边代码是关于numpy的一些基本用法,包括数组和矩阵操作等... import numpy as np print "<== print version ==>" p ...

  6. SQL查询语句 group by后， 字符串合并

    合并列值 --******************************************************************************************* 表 ...

  7. 教你如何精通Struts：Tiles框架

    Tiles框架特性和内容 Tiles框架为创建Web页面提供了一种模板机制,它能将网页的布局和内容分离.它允许先创建模板,然后在运行时动态地将内容插入到模板中.Tiles 框架建立在JSP的inclu ...

  8. C/C++中static关键字作用总结

    来来来,来看这篇文章: http://www.cnblogs.com/biyeymyhjob/archive/2012/07/19/2598815.html 总结一下: 1.先来介绍它的第一条也是最重 ...

  9. js 的小效果---->选项卡

    js选项卡   <!doctype html> <html> <head> <meta charset="utf-8"> <t ...

  10. java读取properties配置文件的方法

    app.properties mail.smtp.host=smtp.163.com mail.transport.protocol=smtp import java.io.InputStream; ...