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. NoSQL数据库的分布式模型

    NoSQL数据库的分布式模型 单一服务器 在一个服务器完全能够胜任工作时就没必要考虑分布式,这样部署简单,维护也方便很多: 分片 特点 数据的各个部分存放在集群的不同服务器中: 比如按字母来划分:以a ...

  2. 构建工具之 - Gradle一般使用常见问答

    Gradle借助Groovy语言作为其配置脚本,使得Gradle变的十分强大,几乎是无所不能,我们在掌控这个强大且功能繁多的工具时也比较困难和凌乱,因此本文记录一些使用过程常见的配置,以备不时之需! ...

  3. 利用tomcat配置网站

    1: 首先将tomcat考到C盘: 2:建立我们存放web应用的目录,我建立在D:\myWeb  ,然后将自己的web应用考到myWeb目录下: 3:wApp的目录结构为: WEB-INF: 结构: ...

  4. maven环境快速搭建（转）

    主要介绍maven在本地安装使用 http://www.cnblogs.com/fnng/archive/2011/12/02/2272610.html   使用Eclipse构建Maven项目 (s ...

  5. iOS - 3DTouch 3D 触摸

    1.3DTouch 简介 3DTouch 是 iOS9 + 系统下,在 iPhone6s(iPhone6s Plus)+ 手机上才能够使用的功能. 1.1 3DTouch 基本类型 1.主屏幕快速选项 ...

  6. eclipse 技巧

    1. eclipse中xml中提示需有xsd文档 如在线eclipse将自动网络获取.xsd 否则 手动本地添加(在xml catalog参数设置选项) 2.当明确实现功能时,可将已有方法抽取成接口, ...

  7. 调整UILabel行高间距并返回自定义宽高度

    // 获取label文字 NSString *labelString = @"XXXXXXXXXXXXXX"; // 设置自定义宽度或高度 CGSize labelSize = C ...

  8. [转发] 理解 oauth 2.0

    原文: http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html oauth 的各种编程语言实现: http://oauth.net/2/ 理解OAu ...

  9. oracle的正则表达式

    阅读目录 1.oracle(regular expression)简单介绍 2.oracle正则特殊字符 3.oracle正则字符簇 4.各种操作符的运算优先级 5.模拟测试例子 6.oracle对应 ...

  10. linux之echo命令

    linux的echo命令, 在shell编程中极为常用, 在终端下打印变量value的时候也是常常用到的, 因此有必要了解下echo的用法 echo命令的功能是在显示器上显示一段文字,一般起到一个提示 ...