线程池浅析及C++代码实现

　　(1)什么是线程池

　　线程池是一种多线程处理技术。线程池先建立好若干线程，并管理这些线程。当有新的任务到来时，将任务添加到一个已建立的空闲线程中执行。线程池所建立的线程优先级都是同样的，因此须要使用特定线程优先级的任务不宜使用线程池。

　　(2)线程池的优势和应用

　　线程池统一管理线程的方式减小了频繁建立和销毁线程的系统调度开销，很大程度上提升了服务器处理并发任务的性能。

　　线程池适用于频繁的任务调度，如处理HTTP请求，任务多，而且任务周期小

　　(3)C++代码实现

　　#include "stdafx.h"

　　#include "stdafx.h"

　　#include

　　#include

　　#include

　　#include

　　using namespace std;

　　class ITask

　　{

　　public：

　　virtual void ProcessTask(void* pUser)=0;

　　};

　　//線程池

　　class CThreadPool

　　{

　　public：

　　class ThreadInfo

　　{

　　public：

　　ThreadInfo() { m_hThread=0;m_bBusyWorking=false;}

　　ThreadInfo(HANDLEhandle， boolbBusy) { m_hThread=handle; m_bBusyWorking=bBusy; }

　　ThreadInfo(const ThreadInfo& info){ m_hThread=info.m_hThread; m_bBusyWorking=info.m_bBusyWorking;}

　　HANDLE m_hThread;

　　bool m_bBusyWorking;

　　};

　　typedef mapThreadInfoMap;

　　typedef ThreadInfoMap：：iterator Iterator_ThreadInfoMap;

　　enum ThreadPoolStatus{ STATUS_BUSY， STATUS_IDLE，STATUS_NORMAL };

　　public：

　　CThreadPool()

　　{

　　InitializeCriticalSection(&m_CS);

　　}

　　virtual ~CThreadPool()

　　{

　　DeleteCriticalSection(&m_CS);

　　}

　　bool Start(unsigned short nStatic， unsigned short nMax)

　　{

　　if(nMax

　　{

　　assert(0);

　　return false;

　　}

　　HANDLE hThread;

　　DWORD nThreadId;

　　m_nNumberOfStaticThreads=nStatic;

　　m_nNumberOfTotalThreads=nMax;

　　//lock the resource

　　EnterCriticalSection(&m_CS);

　　//create an IO port

　　m_hMgrIoPort = CreateIoCompletionPort((HANDLE)INVALID_HANDLE_VALUE，NULL， 0， 0);

　　hThread = CreateThread(

　　NULL， // SD

　　0， // initial stack size

　　(LPTHREAD_START_ROUTINE)ManagerProc， // threadfunction

　　(LPVOID)this， // thread argument

　　0， // creationoption

　　&nThreadId ); // thread identifier

　　m_hMgrThread = hThread;

　　//now we start these worker threads

　　m_hWorkerIoPort = CreateIoCompletionPort((HANDLE)INVALID_HANDLE_VALUE，NULL， 0， 0);

　　for(long n = 0; n < nStatic; n++)

　　{

　　hThread = CreateThread(

　　NULL， // SD

　　0， // initial stack size

　　(LPTHREAD_START_ROUTINE)WorkerProc， // threadfunction

　　(LPVOID)this， //thread argument

　　0， //creation option

　　&nThreadId );

　　m_threadMap.insert(m_threadMap.end()，ThreadInfoMap：：value_type(nThreadId，ThreadInfo(hThread， false)));

　　}

　　LeaveCriticalSection(&m_CS);

　　return true;

　　}

　　void Stop(bool bHash = false)

　　{

　　EnterCriticalSection(&m_CS);

　　：：PostQueuedCompletionStatus(m_hMgrIoPort， 0， 0， (OVERLAPPED*)0xFFFFFFFF);

　　WaitForSingleObject(m_hMgrThread，INFINITE);

　　CloseHandle(m_hMgrThread);

　　CloseHandle(m_hMgrIoPort);

　　//shut down all the worker threads

　　UINT nCount=m_threadMap.size();

　　HANDLE* pThread= new HANDLE[nCount];

　　long n=0;

　　ThreadInfo info;

　　Iterator_ThreadInfoMap i=m_threadMap.begin();

　　while(i!=m_threadMap.end())

　　{

　　：：PostQueuedCompletionStatus(m_hWorkerIoPort， 0， 0， (OVERLAPPED*)0xFFFFFFFF);

　　info=i->second;

　　pThread[n++]=info.m_hThread;

　　i++;

　　}

　　DWORD rc=WaitForMultipleObjects(nCount，pThread， TRUE，30000);//wait for 0.5 minutes， then start to killthreads

　　CloseHandle(m_hWorkerIoPort);

　　if(rc>=WAIT_OBJECT_0 && rc

　　{

　　for(unsigned int n=0;n

　　{

　　CloseHandle(pThread[n]);

　　}

　　}

　　else if(rc==WAIT_TIMEOUT&&bHash)

　　{

　　//some threadsnot terminated， we have to stop them.

　　DWORD exitCode;

　　for(unsigned int i=0; i

　　{

　　if (：：GetExitCodeThread(pThread[i]，&exitCode)==STILL_ACTIVE)

　　{

　　TerminateThread(pThread[i]， 99);

　　}

　　CloseHandle(pThread[i]);

　　}

　　}

　　delete[] pThread;

　　LeaveCriticalSection(&m_CS);

　　}

　　void AddTask(void* pUser， ITask* pWorker)const

　　{

　　：：PostQueuedCompletionStatus(m_hWorkerIoPort， \

　　reinterpret_cast(pWorker)， \

　　reinterpret_cast(pUser)，\

　　NULL);

　　}

　　protected：

　　HANDLE GetMgrIoPort()const { return m_hMgrIoPort; }

　　UINT GetMgrWaitTime()const { return1000; }

　　HANDLE GetWorkerIoPort()const { return m_hWorkerIoPort; }

　　private：

　　static DWORD WINAPI WorkerProc(void* p)

　　{

　　//convert the parameter to the server pointer.

　　CThreadPool* pServer=(CThreadPool*)p;

　　HANDLE IoPort = pServer->GetWorkerIoPort();

　　unsigned long pN1，pN2;

　　OVERLAPPED* pOverLapped;

　　DWORD threadId=：：GetCurrentThreadId();

　　while(：：GetQueuedCompletionStatus(IoPort， &pN1，&pN2，

　　&pOverLapped， INFINITE))

　　{

　　if(pOverLapped ==(OVERLAPPED*)0xFFFFFFFE)

　　{

　　pServer->RemoveThread(threadId);

　　break;

　　}