一个Windows C++的线程池的实现

转载 2016年06月02日 10:47:28

此线程池所依赖的线程类,请参看《一个Windows C++的线程类实现》:

http://blog.csdn.net/huyiyang2010/archive/2010/08/10/5801597.aspx

 

ThreadPoolExecutor.h

  1. #ifndef __THREAD_POOL_EXECUTOR__  
  2. #define __THREAD_POOL_EXECUTOR__  
  3.   
  4. #include "Thread.h"  
  5. #include <set>  
  6. #include <list>  
  7. #include <windows.h>  
  8.   
  9. class CThreadPoolExecutor  
  10. {  
  11. public:  
  12.     CThreadPoolExecutor(void);  
  13.     ~CThreadPoolExecutor(void);  
  14.   
  15.     /** 
  16.       初始化线程池,创建minThreads个线程 
  17.     **/  
  18.     bool Init(unsigned int minThreads, unsigned int maxThreads, unsigned int maxPendingTaskse);  
  19.   
  20.     /** 
  21.       执行任务,若当前任务列表没有满,将此任务插入到任务列表,返回true 
  22.       若当前任务列表满了,但当前线程数量小于最大线程数,将创建新线程执行此任务,返回true 
  23.       若当前任务列表满了,但当前线程数量等于最大线程数,将丢弃此任务,返回false 
  24.     **/  
  25.     bool Execute(Runnable * pRunnable);  
  26.   
  27.     /** 
  28.       终止线程池,先制止塞入任务, 
  29.       然后等待直到任务列表为空, 
  30.       然后设置最小线程数量为0, 
  31.       等待直到线程数量为空, 
  32.       清空垃圾堆中的任务 
  33.     **/  
  34.     void Terminate();  
  35.   
  36.     /** 
  37.       返回线程池中当前的线程数量 
  38.     **/  
  39.     unsigned int GetThreadPoolSize();  
  40.   
  41. private:  
  42.     /** 
  43.       获取任务列表中的任务,若任务列表为空,返回NULL 
  44.     **/  
  45.     Runnable * GetTask();  
  46.   
  47.     static unsigned int WINAPI StaticThreadFunc(void * arg);  
  48.   
  49. private:  
  50.     class CWorker : public CThread  
  51.     {  
  52.     public:  
  53.         CWorker(CThreadPoolExecutor * pThreadPool, Runnable * pFirstTask = NULL);  
  54.         ~CWorker();  
  55.         void Run();  
  56.   
  57.     private:  
  58.         CThreadPoolExecutor * m_pThreadPool;  
  59.         Runnable * m_pFirstTask;  
  60.         volatile bool m_bRun;  
  61.     };  
  62.   
  63.     typedef std::set<CWorker *> ThreadPool;  
  64.     typedef std::list<Runnable *> Tasks;  
  65.     typedef Tasks::iterator TasksItr;  
  66.     typedef ThreadPool::iterator ThreadPoolItr;  
  67.   
  68.     ThreadPool m_ThreadPool;  
  69.     ThreadPool m_TrashThread;  
  70.     Tasks m_Tasks;  
  71.   
  72.     CRITICAL_SECTION m_csTasksLock;  
  73.     CRITICAL_SECTION m_csThreadPoolLock;  
  74.   
  75.     volatile bool m_bRun;  
  76.     volatile bool m_bEnableInsertTask;  
  77.     volatile unsigned int m_minThreads;  
  78.     volatile unsigned int m_maxThreads;  
  79.     volatile unsigned int m_maxPendingTasks;  
  80. };  
  81.   
  82. #endif  

 

 

ThreadPoolExecutor.cpp

  1. #include "ThreadPoolExecutor.h"  
  2.   
  3. CThreadPoolExecutor::CWorker::CWorker(CThreadPoolExecutor * pThreadPool, Runnable * pFirstTask) :   
  4. m_pThreadPool(pThreadPool),  
  5. m_pFirstTask(pFirstTask),  
  6. m_bRun(true)  
  7. {  
  8.       
  9. }  
  10.   
  11. CThreadPoolExecutor::CWorker::~CWorker()  
  12. {  
  13. }  
  14.   
  15. /** 
  16.   执行任务的工作线程。 
  17.   当前没有任务时, 
  18.   如果当前线程数量大于最小线程数量,减少线程, 
  19.   否则,执行清理程序,将线程类给释放掉 
  20. **/  
  21. void CThreadPoolExecutor::CWorker::Run()  
  22. {  
  23.     Runnable * pTask = NULL;  
  24.     while(m_bRun)  
  25.     {  
  26.         if(NULL == m_pFirstTask)  
  27.         {  
  28.             pTask = m_pThreadPool->GetTask();  
  29.         }  
  30.         else  
  31.         {  
  32.             pTask = m_pFirstTask;  
  33.             m_pFirstTask = NULL;  
  34.         }  
  35.   
  36.         if(NULL == pTask)  
  37.         {  
  38.             EnterCriticalSection(&(m_pThreadPool->m_csThreadPoolLock));  
  39.             if(m_pThreadPool->GetThreadPoolSize() > m_pThreadPool->m_minThreads)  
  40.             {  
  41.                 ThreadPoolItr itr = m_pThreadPool->m_ThreadPool.find(this);  
  42.                 if(itr != m_pThreadPool->m_ThreadPool.end())  
  43.                 {  
  44.                     m_pThreadPool->m_ThreadPool.erase(itr);  
  45.                     m_pThreadPool->m_TrashThread.insert(this);  
  46.                 }  
  47.                 m_bRun = false;  
  48.             }  
  49.             else  
  50.             {  
  51.                 ThreadPoolItr itr = m_pThreadPool->m_TrashThread.begin();  
  52.                 while(itr != m_pThreadPool->m_TrashThread.end())  
  53.                 {  
  54.                     (*itr)->Join();  
  55.                     delete (*itr);  
  56.                     m_pThreadPool->m_TrashThread.erase(itr);  
  57.                     itr = m_pThreadPool->m_TrashThread.begin();  
  58.                 }  
  59.             }  
  60.             LeaveCriticalSection(&(m_pThreadPool->m_csThreadPoolLock));  
  61.             continue;  
  62.         }  
  63.         else  
  64.         {  
  65.             pTask->Run();  
  66.             pTask = NULL;  
  67.         }  
  68.     }  
  69. }  
  70.   
  71. /////////////////////////////////////////////////////////////////////////////////////////////  
  72.   
  73. CThreadPoolExecutor::CThreadPoolExecutor(void) :   
  74. m_bRun(false),  
  75. m_bEnableInsertTask(false)  
  76. {  
  77.     InitializeCriticalSection(&m_csTasksLock);  
  78.     InitializeCriticalSection(&m_csThreadPoolLock);  
  79. }  
  80.   
  81. CThreadPoolExecutor::~CThreadPoolExecutor(void)  
  82. {  
  83.     Terminate();  
  84.     DeleteCriticalSection(&m_csTasksLock);  
  85.     DeleteCriticalSection(&m_csThreadPoolLock);  
  86. }  
  87.   
  88. bool CThreadPoolExecutor::Init(unsigned int minThreads, unsigned int maxThreads, unsigned int maxPendingTasks)  
  89. {  
  90.     if(minThreads == 0)  
  91.     {  
  92.         return false;  
  93.     }  
  94.     if(maxThreads < minThreads)  
  95.     {  
  96.         return false;  
  97.     }  
  98.     m_minThreads = minThreads;  
  99.     m_maxThreads = maxThreads;  
  100.     m_maxPendingTasks = maxPendingTasks;  
  101.     unsigned int i = m_ThreadPool.size();  
  102.     for(; i<minThreads; i++)  
  103.     {  
  104.         //创建线程  
  105.         CWorker * pWorker = new CWorker(this);  
  106.         if(NULL == pWorker)  
  107.         {  
  108.             return false;  
  109.         }  
  110.         EnterCriticalSection(&m_csThreadPoolLock);  
  111.         m_ThreadPool.insert(pWorker);  
  112.         LeaveCriticalSection(&m_csThreadPoolLock);  
  113.         pWorker->Start();  
  114.     }  
  115.     m_bRun = true;  
  116.     m_bEnableInsertTask = true;  
  117.     return true;  
  118. }  
  119.   
  120. bool CThreadPoolExecutor::Execute(Runnable * pRunnable)  
  121. {  
  122.     if(!m_bEnableInsertTask)  
  123.     {  
  124.         return false;  
  125.     }  
  126.     if(NULL == pRunnable)  
  127.     {  
  128.         return false;  
  129.     }  
  130.     if(m_Tasks.size() >= m_maxPendingTasks)  
  131.     {  
  132.         if(m_ThreadPool.size() < m_maxThreads)  
  133.         {  
  134.             CWorker * pWorker = new CWorker(this, pRunnable);  
  135.             if(NULL == pWorker)  
  136.             {  
  137.                 return false;  
  138.             }  
  139.             EnterCriticalSection(&m_csThreadPoolLock);  
  140.             m_ThreadPool.insert(pWorker);  
  141.             LeaveCriticalSection(&m_csThreadPoolLock);  
  142.             pWorker->Start();  
  143.         }  
  144.         else  
  145.         {  
  146.             return false;  
  147.         }  
  148.     }  
  149.     else  
  150.     {  
  151.         EnterCriticalSection(&m_csTasksLock);  
  152.         m_Tasks.push_back(pRunnable);  
  153.         LeaveCriticalSection(&m_csTasksLock);  
  154.     }  
  155.     return true;  
  156. }  
  157.   
  158. Runnable * CThreadPoolExecutor::GetTask()  
  159. {  
  160.     Runnable * Task = NULL;  
  161.     EnterCriticalSection(&m_csTasksLock);  
  162.     if(!m_Tasks.empty())  
  163.     {  
  164.         Task = m_Tasks.front();  
  165.         m_Tasks.pop_front();  
  166.     }  
  167.     LeaveCriticalSection(&m_csTasksLock);  
  168.     return Task;  
  169. }  
  170.   
  171. unsigned int CThreadPoolExecutor::GetThreadPoolSize()  
  172. {  
  173.     return m_ThreadPool.size();  
  174. }  
  175.   
  176. void CThreadPoolExecutor::Terminate()  
  177. {  
  178.     m_bEnableInsertTask = false;  
  179.     while(m_Tasks.size() > 0)  
  180.     {  
  181.         Sleep(1);  
  182.     }  
  183.     m_bRun = false;  
  184.     m_minThreads = 0;  
  185.     m_maxThreads = 0;  
  186.     m_maxPendingTasks = 0;  
  187.     while(m_ThreadPool.size() > 0)  
  188.     {  
  189.         Sleep(1);  
  190.     }  
  191.     EnterCriticalSection(&m_csThreadPoolLock);  
  192.     ThreadPoolItr itr = m_TrashThread.begin();  
  193.     while(itr != m_TrashThread.end())  
  194.     {  
  195.         (*itr)->Join();  
  196.         delete (*itr);  
  197.         m_TrashThread.erase(itr);  
  198.         itr = m_TrashThread.begin();  
  199.     }  
  200.     LeaveCriticalSection(&m_csThreadPoolLock);  
  201. }  

 

 

用法:

#include "Thread.h"
#include "ThreadPoolExecutor.h"

class R : public Runnable
{
public:
    ~R()
    {
    }
    void Run()
    {
        printf("Hello World/n");
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    CThreadPoolExecutor * pExecutor = new CThreadPoolExecutor();
    pExecutor->Init(1, 10, 50);
    R r;
    for(int i=0;i<100;i++)
    {
        while(!pExecutor->Execute(&r))
        {
        }
    }
    pExecutor->Terminate();
    delete pExecutor;
    getchar();
    return 0;
}

 

测试结果:

机器:

Intel(R) Core(TM)2 Duo CPU

E8400 @ 3.00GHz

2G内存

 

对于100个任务并且每个任务包含10000000个循环,任务中无等待:

单线程执行耗时:2281时间片

单线程池执行耗时:2219时间片

2个线程的线程池耗时:1156时间片

5个线程的线程池耗时:1166时间片

10个线程的线程池耗时:1157时间片

100个线程的线程池耗时:1177时间片

 

 

from:

《Windows核心编程系列》十一谈谈Windows线程池

Windows线程池        上一篇博文我们介绍了IO完成端口。得知IO完成端口可以非常智能的分派线程。但是IO完成端口仅对等待它的线程进行分派,创建和销毁线程的工作仍然需要我们自己来做。 ...
  • ithzhang
  • ithzhang
  • 2012年12月22日 15:41
  • 15533

Windows下一个比较完美的线程池实现(更新)

1.  前言 线程池不是一个新鲜的东西,网上能找到很多原理、实现,甚至很多库都提供了实现,比如微软的 ATL::CThreadPool, Vista后提供的CreateThreadpoolWork, ...
  • fishjam
  • fishjam
  • 2013年03月03日 23:45
  • 17573

Windows线程池

1、Windows提供了一个线程池机制来简化线程的创建、销毁以及日常管理

Windows系统线程池+利用windows自带的线程池

一直想弄明白Windows的IO完成端口是什么,这个词语每每出现在我眼前时总是伴随着鲜花和赞美,因此我便将其同许多我从来没搞懂过的东西一起归为神秘一类。这两天一直在看《Windows核心编程》,学到了...
  • CtiyMan
  • CtiyMan
  • 2015年08月11日 16:46
  • 709

WIndows编程之线程池的使用

哎,习惯了CSDN,再去博客园实在有点不适应,虽然CSDN广告多,就这么忍着吧。这篇是我写在博客园的博客,特地搬过来了。T_T不得不说,做C++服务器程序开发,要是不理解线程池,不懂线程池,做C++服...

一个Windows C++的线程池的实现

此线程池所依赖的线程类,请参看《一个Windows C++的线程类实现》: http://blog.csdn.net/huyiyang2010/archive/2010/08/10/580159...

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

windows编程之线程池

在讲线程池之前,我们先来看下“池”是什么意思。 “池”,我把他归结为一大堆的资源,比如说,内存,线程,网络连接,数据库的连接等一系列的资源,因而与之相对应的就有,内存池,线程池,网络连接池,数据库连接...
  • Timmiy
  • Timmiy
  • 2016年07月05日 22:09
  • 655

Windows多线程(一) 最简单的多线程

本篇系列参考MoreWindows系列秒杀多线程:

Windows线程池

文章来源:http://www.cnblogs.com/coser/archive/2012/03/10/2389264.html 什么是线程池? 诸如web服务器、数据库服务器、文件服务器和邮...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:一个Windows C++的线程池的实现
举报原因:
原因补充:

(最多只允许输入30个字)