转载:C++线程池的一个实现

原文转自：http://www.cnblogs.com/lidabo/p/3328646.html

略有修改

Cthread类参见：http://www.cnblogs.com/tangxin-blog/p/4835211.html

CThreadPool.h

 #ifndef __MY_THREAD_POOL_H_
 #define __MY_THREAD_POOL_H_

 #include "CThread.h"
 #include <set>
 #include <list>
 #include <windows.h>
 using namespace std;

 class CThreadPool
 {
 public:
     CThreadPool(void);
     virtual ~CThreadPool(void);
     // 初始化线程池，创建minThreads个线程
     bool Initialize(unsigned int minThreadCnt,unsigned int maxThreadCnt,unsigned int maxTaskQueueLength);
     bool AddTask( CRunnable *pRunnable, bool bRun = true);
     void Terminate();
     // 获取线程数量
     unsigned int GetThreadCnt();
 private:
     // 从任务队列头中取出一个任务
     CRunnable *GetTask();
     // 执行任务线程
     static unsigned int WINAPI StaticThreadFunc(void * arg);
 private:
     // 工作者类
     class CWorker : public CThread
     {
     public:
         CWorker(CThreadPool *pThreadPool,CRunnable *pFirstTask = NULL);
         ~CWorker();
         void Run();
     private:
         CThreadPool * const m_pThreadPool;
         CRunnable * const m_pFirstTask;
         volatile bool m_bRun;
     };

     typedef std::set<CWorker *> ThreadPool;
     typedef std::list<CRunnable *> Tasks;
     typedef Tasks::iterator TasksItr;
     typedef ThreadPool::iterator ThreadPoolItr;

     CRITICAL_SECTION m_csTasksLock;
     CRITICAL_SECTION m_csThreadPoolLock;  

     // 线程池
     ThreadPool m_ThreadPool;
     // 垃圾线程
     ThreadPool m_TrashThread;
     // 任务队列
     Tasks m_Tasks;
     // 是否在运行
     volatile bool m_bRun;
     // 能否插入任务
     volatile bool m_bEnableInsertTask;
     // 最小线程数
     volatile unsigned int m_minThreads;
     // 最大线程数
     volatile unsigned int m_maxThreads;
     // 最大挂起任务数量
     volatile unsigned int m_maxPendingTasks;
 };

 #endif

CthreadPool.cpp

#include "CThreadPool.h"

CThreadPool::CWorker::CWorker(CThreadPool *pThreadPool,CRunnable *pFirstTask)
    :m_pThreadPool(pThreadPool),m_pFirstTask(pFirstTask),m_bRun(true)
{

}

CThreadPool::CWorker::~CWorker()
{
}

void CThreadPool::CWorker::Run()
{
    CRunnable * pTask = NULL;
    while(m_bRun)
    {
        // 从线程池的任务队列中取出一个任务
        pTask = m_pThreadPool->GetTask();
        // 如果没有取到任务
        if(NULL == pTask)
        {
            EnterCriticalSection(&(m_pThreadPool->m_csThreadPoolLock));
            // 如果运转的线程数大于最小线程数，需要清除多余的线程
            if(m_pThreadPool->GetThreadCnt() > m_pThreadPool->m_minThreads)
            {
                ThreadPoolItr itr = m_pThreadPool->m_ThreadPool.find(this);
                if(itr != m_pThreadPool->m_ThreadPool.end())
                {
                    m_pThreadPool->m_ThreadPool.erase(itr);
                    m_pThreadPool->m_TrashThread.insert(this);
                }
                m_bRun = false;
            }
            else
            {
                // 等待已经开始运行的线程结束
                ThreadPoolItr itr = m_pThreadPool->m_TrashThread.begin();
                while(itr != m_pThreadPool->m_TrashThread.end())
                {
                    (*itr)->Join();
                    delete (*itr);
                    m_pThreadPool->m_TrashThread.erase(itr);
                    itr = m_pThreadPool->m_TrashThread.begin();
                }
            }
            LeaveCriticalSection(&(m_pThreadPool->m_csThreadPoolLock));
            continue;
        }
        else
        {
            pTask->Run();
            pTask = NULL;
        }
    }
}

CThreadPool::CThreadPool(void):m_bRun(false),m_bEnableInsertTask(false)
{
    InitializeCriticalSection(&m_csTasksLock);
    InitializeCriticalSection(&m_csThreadPoolLock);
}

CThreadPool::~CThreadPool(void)
{
    Terminate();
    DeleteCriticalSection(&m_csTasksLock);
    DeleteCriticalSection(&m_csThreadPoolLock);
}

bool CThreadPool::Initialize(unsigned int minThreadCnt,unsigned int maxThreadCnt,unsigned int maxTaskQueueLength)
{
    if(minThreadCnt == )
    {
        return false;
    }
    if(minThreadCnt > maxThreadCnt)
    {
        return false;
    }
    m_minThreads = minThreadCnt;
    m_maxThreads = maxThreadCnt;
    m_maxPendingTasks = maxTaskQueueLength;
    unsigned int i = m_ThreadPool.size();
    for(; i<minThreadCnt; i++)
    {
        //创建线程 minThreadCnt 个线程
        CWorker * pWorker = new CWorker(this);
        if(NULL == pWorker)
        {
            return false;
        }
        EnterCriticalSection(&m_csThreadPoolLock);
        m_ThreadPool.insert(pWorker);
        LeaveCriticalSection(&m_csThreadPoolLock);
        pWorker->Start();
    }
    // 可以开始插入任务队列
    m_bRun = true;
    m_bEnableInsertTask = true;
    return true;
}

unsigned int CThreadPool::GetThreadCnt()
{
    return m_ThreadPool.size();
}

CRunnable * CThreadPool::GetTask()
{
    CRunnable *Task = NULL;
    EnterCriticalSection(&m_csTasksLock);
    if(!m_Tasks.empty())
    {
        Task = m_Tasks.front();
        m_Tasks.pop_front();
    }
    LeaveCriticalSection(&m_csTasksLock);
    return Task;
}

bool CThreadPool::AddTask( CRunnable *pRunnable, bool bRun /*= true*/ )
{
    if(m_bEnableInsertTask == false)
    {
        return false;
    }
    if(NULL == pRunnable)
    {
        return false;
    }
    // 如果达到最大挂起任务数量,不再插入
    if(m_Tasks.size() >= m_maxPendingTasks)
    {
        // 如果小于最大线程数
        if(m_ThreadPool.size() < m_maxThreads)
        {
            CWorker * pWorker = new CWorker(this, pRunnable);
            if(NULL == pWorker)
            {
                return false;
            }
            EnterCriticalSection(&m_csThreadPoolLock);
            m_ThreadPool.insert(pWorker);
            LeaveCriticalSection(&m_csThreadPoolLock);
            pWorker->Start();
        }
        else
        {
            return false;
        }
    }
    else
    {
        EnterCriticalSection(&m_csTasksLock);
        m_Tasks.push_back(pRunnable);
        LeaveCriticalSection(&m_csTasksLock);
    }
    return true;
}

void CThreadPool::Terminate()
{
    m_bEnableInsertTask = false;
    while(m_Tasks.size() > )
    {
        Sleep();
    }
    m_bRun = false;
    m_minThreads = ;
    m_maxThreads = ;
    m_maxPendingTasks = ;
    while(m_ThreadPool.size() > )
    {
        Sleep();
    }
    EnterCriticalSection(&m_csThreadPoolLock);
    ThreadPoolItr itr = m_TrashThread.begin();
    while(itr != m_TrashThread.end())
    {
        (*itr)->Join();
        delete (*itr);
        m_TrashThread.erase(itr);
        itr = m_TrashThread.begin();
    }
    LeaveCriticalSection(&m_csThreadPoolLock);
}

测试代码

#include <iostream>
#include <windows.h>
#include <time.h>
#include "CThread.h"
#include "CThreadPool.h"
using namespace std;

class R : public CRunnable
{
public:
    R(int t):m_nt(t)
    {
    }
    ~R()
    {
        cout<<"~R:"<<m_nt<<endl;
    }
    void Run()
    {
        Sleep(m_nt);
    }
    int m_nt;
};

int main()
{
    int i,n = ,m;
    time_t start = ,end = ;
    R r();
    /*
    // 单线程
    start = clock();
    for(i=0;i < n;i++)
    {
        r.Run();
    }
    end = clock();
    cout<<"单线程用时:"<<end - start<<endl;
    */
    // 多线程
    start = clock();
    CThread *ths = NULL;
    ths = new CThread[n];
    for(i=;i < n;i++)
    {
        ths[i].SetRunnable(&r);
        ths[i].Start();
    }
    for(i=;i < n;i++)
    {
        ths[i].Join();
    }
    delete[] ths;
    end = clock();
    cout<<"多线程用时:"<<end - start<<endl;
    // 线程池
    start = clock();
    CThreadPool *threadPool = new CThreadPool();
    if(threadPool->Initialize(,,) == false)
    {
        cout<<"Initialize failed"<<endl;
        return -;
    }
    m = ;
    for(int i=;i<n;i++)
    {
        if( !threadPool->AddTask(&r) )
        {
            m++;
        }
    }
    threadPool->Terminate();
    delete threadPool;
    end = clock();
    if(m!=)
    {
        cout<<m<<endl;
    }
    cout<<"线程池用时:"<<end - start<<endl;
    system("pause");
    return ;
}

注意：要合理设置最小线程数，最大线程数，最大挂起任务数量，以便达到最优性能。