程序博客网 > 北京二手房成交数据

线程池例程

来源：互联网 发布：北京二手房成交数据 编辑：程序博客网 时间：2024/05/17 09:11
  1. 类定义如下
  3. // ThreadPoolImp.h: interface for the ThreadPoolImp class.
  4. //
  5. //////////////////////////////////////////////////////////////////////
  7. #if !defined(AFX_THREADPOOLIMP_H__82F4FC7E_2DB4_4D2A_ACC8_2EFC787CAE42__INCLUDED_)
  8. #define AFX_THREADPOOLIMP_H__82F4FC7E_2DB4_4D2A_ACC8_2EFC787CAE42__INCLUDED_
  10. #if _MSC_VER > 1000
  11. #pragma once
  12. #endif // _MSC_VER > 1000
  15. #pragma warning( disable : 4705 4786)
  17. #include <map>
  18. #include "AutoLock.h"
  20. using namespace std;
  22. class IJobDesc;
  23. class IWorker;
  25. class CThreadPoolImp 
  26. {
  27. public:
  28. class ThreadInfo
  29. {
  30. public:
  31. ThreadInfo() { m_hThread=0; m_bBusyWorking=false; }
  32. ThreadInfo(HANDLE handle, bool bBusy) { m_hThread=handle; m_bBusyWorking=bBusy; }
  33. ThreadInfo(const ThreadInfo& info) { m_hThread=info.m_hThread; m_bBusyWorking=info.m_bBusyWorking; }
  34. ////////
  35. HANDLE m_hThread;
  36. boolm_bBusyWorking;
  37. };
  39. typedef map<DWORD,ThreadInfo> ThreadInfoMap;
  40. typedef ThreadInfoMap::iterator Iterator_ThreadInfoMap;
  42. friend static unsigned int CThreadPoolImp::ManagerProc(void* p); 
  43. friend static unsigned int CThreadPoolImp::WorkerProc(void* p);
  44. protected:
  45. enum ThreadPoolStatus { BUSY, IDLE, NORMAL };
  46. public:
  47. //interface to the outside
  48. void Start(unsigned short nStatic, unsigned short nmax);
  49. void Stop(bool bHash=false);
  50. void ProcessJob(IJobDesc* pJob, IWorker* pWorker) const;
  52. //constructor and destructor
  53. CThreadPoolImp();
  54. virtual ~CThreadPoolImp();
  56. protected:
  57. //interfaces public:
  58. HANDLE GetMgrIoPort() const { return m_hMgrIoPort; }
  59. UINT GetMgrWaitTime() const { return 1000; }
  60. HANDLE GetWorkerIoPort() const { return m_hWorkerIoPort; }
  62. private:
  63. static DWORD WINAPI ManagerProc(void* p);
  64. static DWORD WINAPI WorkerProc(void* p);
  65. protected:
  66. //manager thread
  67. HANDLE m_hMgrThread;
  68. HANDLE m_hMgrIoPort;
  69. protected:
  70. //configuration parameters
  71. mutable unsigned short m_nNumberOfStaticThreads;
  72. mutable unsigned short m_nNumberOfTotalThreads;
  74. protected:
  75. //helper functions
  76. void AddThreads();
  77. void RemoveThreads();
  78. ThreadPoolStatus GetThreadPoolStatus();
  79. void ChangeStatus(DWORD threadId, bool status);
  80. void RemoveThread(DWORD threadId);
  82. protected:
  83. //all the work threads
  84. ThreadInfoMap m_threadMap;
  85. CCriticalSection m_arrayCs;
  86. HANDLE m_hWorkerIoPort;
  87. };
  89. #endif // !defined(AFX_THREADPOOLIMP_H__82F4FC7E_2DB4_4D2A_ACC8_2EFC787CAE42__INCLUDED_)
  92. 实现如下
  95. // ThreadPool.cpp: implementation of the CThreadPoolImp class.
  96. //
  97. //////////////////////////////////////////////////////////////////////
  99. #include "stdafx.h"
  100. #include "ThreadPoolimp.h"
  101. #include "outdebug.h"
  102. #include <assert.h>
  103. #include "work.h"
  105. #ifdef _DEBUG
  106. #undef THIS_FILE
  107. static char THIS_FILE[]=__FILE__;
  108. //#define new DEBUG_NEW
  109. #endif
  111. CThreadPoolImp::CThreadPoolImp()
  112. {
  113. }
  115. CThreadPoolImp::~CThreadPoolImp()
  116. {
  118. }
  120. void CThreadPoolImp::Start(unsigned short nStatic, unsigned short nMax)
  121. {
  122. assert(nMax>=nStatic);
  123. HANDLE hThread;
  124. DWORDnThreadId;
  125. m_nNumberOfStaticThreads=nStatic;
  126. m_nNumberOfTotalThreads=nMax;
  128. //lock the resource
  129. CAutoLock AutoLock(m_arrayCs);
  131. //create an IO port
  132. m_hMgrIoPort = CreateIoCompletionPort((HANDLE)INVALID_HANDLE_VALUE, NULL, 0, 0);
  133. hThread = CreateThread(
  134. NULL, // SD
  135. 0, // initial stack size
  136. (LPTHREAD_START_ROUTINE)ManagerProc, // thread function
  137. (LPVOID)this, // thread argument
  138. 0, // creation option
  139. &nThreadId ); // thread identifier
  140. m_hMgrThread = hThread;
  142. //now we start these worker threads
  143. m_hWorkerIoPort = CreateIoCompletionPort((HANDLE)INVALID_HANDLE_VALUE, NULL, 0, 0);
  144. for(long n = 0; n < nStatic; n )
  145. {
  146. hThread = CreateThread(
  147. NULL, // SD
  148. 0, // initial stack size
  149. (LPTHREAD_START_ROUTINE)WorkerProc, // thread function
  150. (LPVOID)this, // thread argument
  151. 0, // creation option
  152. &nThreadId ); 
  153. ReportDebug("generate a worker thread handle id is d./n", nThreadId);
  154. m_threadMap.insert(m_threadMap.end(),ThreadInfoMap::value_type(nThreadId,ThreadInfo(hThread, false)));
  155. }
  156. }
  158. void CThreadPoolImp::Stop(bool bHash)
  159. {
  160. CAutoLock Lock(m_arrayCs);
  162. ::PostQueuedCompletionStatus(m_hMgrIoPort, 0, 0, (OVERLAPPED*)0xFFFFFFFF);
  163. WaitForSingleObject(m_hMgrThread, INFINITE);
  164. CloseHandle(m_hMgrThread);
  165. CloseHandle(m_hMgrIoPort);
  167. //shut down all the worker threads
  168. UINT nCount=m_threadMap.size();
  169. HANDLE* pThread = new HANDLE[nCount];
  170. long n=0;
  171. ThreadInfo info;
  172. Iterator_ThreadInfoMap i=m_threadMap.begin();
  173. while(i!=m_threadMap.end())
  174. {
  175. ::PostQueuedCompletionStatus(m_hWorkerIoPort, 0, 0, (OVERLAPPED*)0xFFFFFFFF);
  176. info=i->second;
  177. pThread[n ]=info.m_hThread;
  178. i ;
  179. }
  181. DWORD rc=WaitForMultipleObjects(nCount, pThread, TRUE, 30000);//wait for 0.5 minutes, then start to kill threads
  182. CloseHandle(m_hWorkerIoPort);
  183. if(rc>=WAIT_OBJECT_0 && rc<WAIT_OBJECT_0 nCount)
  184. {
  185. for(unsigned int n=0;n<nCount;n )
  186. {
  187. CloseHandle(pThread[n]);
  188. }
  189. }
  190. else if(rc==WAIT_TIMEOUT&&bHash)
  191. {
  192. //some threads not terminated, we have to stop them.
  193. DWORD exitCode;
  194. for(unsigned int i=0; i<nCount; i )
  195. {
  196. if (::GetExitCodeThread(pThread[i], &exitCode)==STILL_ACTIVE)
  197. {
  198. TerminateThread(pThread[i], 99);
  199. }
  200. CloseHandle(pThread[i]);
  201. }
  202. }
  203. delete[] pThread;
  204. }
  206. DWORD WINAPI CThreadPoolImp::ManagerProc(void* p)
  207. {
  208. //convert the parameter to the server pointer.
  209. CThreadPoolImp* pServer=(CThreadPoolImp*)p;
  210. HANDLEIoPort= pServer->GetMgrIoPort();
  211. unsigned longpN1, pN2; 
  212. OVERLAPPED*pOverLapped;
  214. LABEL_MANAGER_PROCESSING:
  215. while(::GetQueuedCompletionStatus(IoPort, &pN1, &pN2, 
  216. &pOverLapped, pServer->GetMgrWaitTime() ))
  217. {
  218. if(pOverLapped == (OVERLAPPED*)0xFFFFFFFF)
  219. {
  220. return 0;
  221. }
  222. //else if(pOverLapped == (OVERLAPPED*)0xFFFFFFFE)
  223. //{
  224. //if(pN1!=0)
  225. //{
  226. //DWORD rc=::WaitForSingleObject((HANDLE)pN1,INFINITE);
  227. //if(rc=WAIT_OBJECT_0)
  228. //{
  229. //CloseHandle((HANDLE)pN1);//关闭该线程句柄
  230. //}
  231. //ReportDebug("Wait a Thread Removed!/n");
  232. //}
  233. //}
  234. else 
  235. {
  236. ReportDebug("mgr events comes in!/n");
  237. }
  238. }
  240. //time out processing
  241. if (::GetLastError()==WAIT_TIMEOUT)
  242. {
  243. //time out processing
  244. ReportDebug("Time out processing!/n");
  245. //the manager will take a look at all the worker's status. The
  246. if (pServer->GetThreadPoolStatus()==CThreadPoolImp::BUSY)
  247. pServer->AddThreads();
  248. if (pServer->GetThreadPoolStatus()==CThreadPoolImp::IDLE)
  249. pServer->RemoveThreads();
  251. goto LABEL_MANAGER_PROCESSING;
  252. }
  253. return 0;
  254. }
  256. DWORD WINAPI CThreadPoolImp::WorkerProc(void* p)
  257. {
  258. //convert the parameter to the server pointer.
  259. CThreadPoolImp* pServer=(CThreadPoolImp*)p;
  260. HANDLEIoPort= pServer->GetWorkerIoPort();
  261. unsigned longpN1, pN2; 
  262. OVERLAPPED*pOverLapped;
  264. DWORD threadId=::GetCurrentThreadId();
  265. ReportDebug("worker thread id is d./n", threadId);
  267. while(::GetQueuedCompletionStatus(IoPort, &pN1, &pN2, 
  268. &pOverLapped, INFINITE ))
  269. {
  270. if(pOverLapped == (OVERLAPPED*)0xFFFFFFFE)
  271. {
  273. //CThreadPoolImp::Iterator_ThreadInfoMap it=pServer->m_threadMap.find(threadId);
  274. //if(it!=pServer->m_threadMap.end())
  275. //{
  276. //::PostQueuedCompletionStatus(pServer->m_hMgrIoPort,
  277. //(unsigned long)it->second.m_hThread,
  278. //0, 
  279. //(OVERLAPPED*)0xFFFFFFFE);
  280. pServer->RemoveThread(threadId);
  281. //ReportDebug("Try to Remove a Thread/n");
  282. //}
  283. break;
  284. }
  285. else if(pOverLapped == (OVERLAPPED*)0xFFFFFFFF)
  286. {
  287. break;
  288. }
  289. else
  290. {
  291. ReportDebug("worker events comes in!/n");
  292. //before processing, we need to change the status to busy.
  293. pServer->ChangeStatus(threadId, true);
  294. //retrieve the job description and agent pointer
  295. IWorker* pIWorker = reinterdivt_cast<IWorker*>(pN1);
  296. IJobDesc* pIJob= reinterdivt_cast<IJobDesc*>(pN2);
  297. pIWorker->ProcessJob(pIJob);
  298. pServer->ChangeStatus(threadId, false);
  299. }
  300. }
  301. return 0;
  302. }
  304. void CThreadPoolImp::ChangeStatus(DWORD threadId, bool status)
  305. {
  306. CAutoLock CAutoLock(m_arrayCs);
  308. //retrieve the current thread handle
  309. Iterator_ThreadInfoMap i;
  310. ThreadInfo info;
  311. i=m_threadMap.find(threadId);
  312. info=i->second;
  313. //m_threadMap.Lookup(threadId, info);
  314. info.m_bBusyWorking=status;
  315. m_threadMap.insert(m_threadMap.end(),ThreadInfoMap::value_type(threadId, info));
  316. }
  318. void CThreadPoolImp::ProcessJob(IJobDesc* pJob, IWorker* pWorker) const
  319. {
  320. ::PostQueuedCompletionStatus(m_hWorkerIoPort, /
  321. reinterdivt_cast<DWORD>(pWorker), /
  322. reinterdivt_cast<DWORD>(pJob),/
  323. NULL);
  324. }
  326. void CThreadPoolImp::AddThreads()
  327. {
  328. HANDLE hThread;
  329. DWORDnThreadId;
  330. unsigned int nCount=m_threadMap.size();
  331. unsigned int nTotal=min(nCount 2, m_nNumberOfTotalThreads);
  332. for(unsigned int i=0; i<nTotal-nCount; i )
  333. {
  334. hThread = CreateThread(
  335. NULL, // SD
  336. 0, // initial stack size
  337. (LPTHREAD_START_ROUTINE)WorkerProc, // thread function
  338. (LPVOID)this, // thread argument
  339. 0, // creation option
  340. &nThreadId ); 
  341. ReportDebug("generate a worker thread handle id is d./n", nThreadId);
  342. m_threadMap.insert(m_threadMap.end(),ThreadInfoMap::value_type(nThreadId,ThreadInfo(hThread, false)));
  343. }
  344. }
  346. void CThreadPoolImp::RemoveThread(DWORD threadId)
  347. {
  348. CAutoLock lock(m_arrayCs);
  349. m_threadMap.erase(threadId);
  350. }
  352. void CThreadPoolImp::RemoveThreads()
  353. {
  354. unsigned int nCount=m_threadMap.size();
  355. unsigned int nTotal=max(nCount-2, m_nNumberOfStaticThreads);
  356. for(unsigned int i=0; i<nCount-nTotal; i )
  357. {
  358. ::PostQueuedCompletionStatus(m_hWorkerIoPort, 0, 0, (OVERLAPPED*)0xFFFFFFFE);
  359. }
  360. }
  362. CThreadPoolImp::ThreadPoolStatus CThreadPoolImp::GetThreadPoolStatus()
  363. {
  364. int nTotal = m_threadMap.size();
  365. ThreadInfo info;
  366. int nCount=0;
  367. Iterator_ThreadInfoMap i=m_threadMap.begin(); 
  368. while(i!=m_threadMap.end())
  369. {
  370. info=i->second;
  371. if (info.m_bBusyWorking==true) nCount ;
  372. i ;
  373. }
  374. if ( nCount/(1.0*nTotal) > 0.8 )
  375. return BUSY;
  376. if ( nCount/ (1.0*nTotal) < 0.2 )
  377. return IDLE;
  378. return NORMAL;
  379. }
北京二手房成交数据 北京二手房成交数据
原创粉丝点击
热门IT博客
spc cloud软件下载spc cloud软件下载
thinkphp 源码分析thinkphp 源码分析
mac替换快捷键
mac上查看隐藏照片
成都行知小学
php linux 全部删除
淘宝助理 顺丰模板
pe管道绘图软件
致命弯道知乎
什么软件免费打电话
手机注册界面html源码
vlc media player mac
松下plc编程软件官网
微波炉哪款好用 知乎
明道软件怎么样
淘宝被投诉盗图扣几分
安捷伦数据采集
大数据统计学就业前景
幸运转盘抽奖软件
达内软件招聘
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 受到apr攻击怎么办 arp攻击怎么办 二胎怀不上孕怎么办 二胎准生证怎么办 异地二胎准生证怎么办 甩棍收不回来怎么办 信用卡额度用完怎么办 外汇额度没有怎么办 方向盘锁死了怎么办 方向盘锁了怎么办 方向盘锁住了怎么办 车被锁了怎么办 车轮胎被锁了怎么办 方向盘被锁死怎么办 帽子老是掉怎么办 sd值偏高怎么办 火车站扣留东西怎么办 火车行李超重怎么办 刀具生锈怎么办 坐飞机打火机怎么办 孕妇机场安检怎么办 监外执行到期了怎么办 电瓶车被偷怎么办 电瓶被偷怎么办 橡皮泥干了怎么办 杜鹃根不沉水怎么办 没有月饼模具怎么办 加绒裤子掉毛怎么办 一号店发错货怎么办 手机一直震动怎么办 做生意没有本钱怎么办 卫生间门打不开怎么办 京东天猫卖假货怎么办 tvoc是什么超标怎么办 键盘灯不亮了怎么办 遇到灯饰骗局怎么办 牛仔裤太长怎么办 硬盘驱动器坏了怎么办 电脑没有驱动器怎么办 csgo永久不可信怎么办 ie阻止cookie怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里