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. poj 2398 （叉积+二分）

    http://poj.org/problem?id=2398 Toy Storage Time Limit: 1000MS   Memory Limit: 65536K Total Submissio ...

  2. 使用一个封装的json删除方法

    <!-- 前台js代码:其实现的目的:利用异步的封装方法实现增删改操作!--> <script type="text/javascript"> functi ...

  3. iOS - Swift Set 集合

    前言 Set:集合 public struct Set<Element : Hashable> : Hashable, CollectionType, ArrayLiteralConver ...

  4. set使用

    package com.cz.test.util.collection; import java.util.ArrayList;import java.util.Collection;import j ...

  5. HDU1542矩形面积并

    取出纵向边按x坐标排序,在y方向上建立线段树. 每次查询当前有效长度len,ans += len*(x[i]-x[i-1]); 其中len为T[rt].len; 查询完毕后更新y方向上线段树,入边+1 ...

  6. 几种HtmlEncode的区别(转)

    一.C#中的编码 HttpUtility.HtmlDecode.HttpUtility.HtmlEncode与Server.HtmlDecode.Server.HtmlEncode与HttpServe ...

  7. (四)802.1Q VLAN

  8. Erlang安装笔记

    今天,为了安装RabbitMQ,需要安装Erlang,中间遇到了一些坑,记录下来. 1. 下载Erlang安装包 http://www.erlang.org/downloads http://erla ...

  9. 【CDN】国外访问国内服务器网站-响应慢-CDN

    建议采用CDN海外加速方式: (1)CDN即内容分发网络(Content Delievery Network),它可以认为是建立在现有IP网络基础结构之上的一种增值网络.CDN技术将多点负载均衡.镜像 ...

  10. JS 判断当前使用浏览器名及版本

    由于我的后台系统的上传图片不支持IE浏览器的,所以我需要判断公司人员在使用后台系统的时候,是否使用的浏览器是IE的. // 获取当前浏览器名 及 版本号 function appInfo(){ var ...