可伸缩多线程任务队列
在我们的工作中，我们经常需要异步执行一些任务，下面介绍的这个可伸缩多线程队列，可满足我们的需求。
出自：http://www.codeproject.com/Articles/4148/Multithreaded-Job-Queue，主要有以下几个功能：
1、任务队列是多线程，许多任务可以异步进行，任务队列使用线程池来执行任务。
2、任务队列支持优先级，优先级高的任务优先执行(即使是后来添加的)
3、任务队列可以被暂停，但是用户还是可以添加任务，当任务队列被唤醒时，任务可以继续执行下去
4、在运行过程中，任务队列使用的线程池，用户可以自行增加和减少
大体框架主要由3个类构成
1、CJob，任务类，用户需要从该类派生来实现自身需要完成的任务
2、CJobExecuter，任务执行类，任务均由该类来调用执行，每一个类相当于对应一个线程
3、CMThreadedJobQ，多线程任务队列，添加任务已经任务的分发均由该类完成，该类维护一个任务队列和一个完成队列的线程池。
类图如下：
该例子中，CJobExecuter和CMThreadJobQ这两个类的调用关系是非常值得我们学习的，同时，CJob作为一个基类，子类派生可以实现不同的任务，可扩展性也不错。源代码解析如下：
Job.h文件：
class CJob { public: CJob(); virtual ~CJob(); BOOL m_Completed; //任务是否完成：TRUE 完成，FALSE 未完成 static long lastUsedID; //最后的ID //================================================================================================ //函数名： setPriority //函数描述： 设置任务优先级 //输入： [in] priority 优先级别 //输出： 无 //返回： 无 //================================================================================================ void setPriority(int priority); //================================================================================================ //函数名： getPriority //函数描述： 返回任务优先级 //输入： 无 //输出： 无 //返回： 任务优先级 //================================================================================================ int getPriority(); //================================================================================================ //函数名： getID //函数描述： 返回任务ID //输入： 无 //输出： 无 //返回： 任务ID //================================================================================================ long getID(); //================================================================================================ //函数名： setAutoDelete //函数描述： 设置完成任务后是否删除任务 //输入： [in] autoDeleteFlag //输出： 无 //返回： 无 //================================================================================================ void setAutoDelete(BOOL autoDeleteFlag = TRUE); //================================================================================================ //函数名： AutoDelete //函数描述： 返回删除任务标记 //输入： 无 //输出： 无 //返回： 任务标记 //================================================================================================ BOOL AutoDelete(); //================================================================================================ //函数名： execute //函数描述： 任务真正工作的函数，纯虚函数，需要子类化实现 //输入： 无 //输出： 无 //返回： 任务ID //================================================================================================ virtual void execute() = 0; private: long m_ID; //任务ID BOOL m_autoDeleteFlag; //是否自动删除任务标记，TRUE 删除，FALSE 不删除，默认为TRUE int m_priority; //任务优先级，默认为5 };
Job.cpp文件：
long CJob::lastUsedID = 0; CJob::CJob() { this->m_ID = InterlockedIncrement(&lastUsedID); this->m_autoDeleteFlag = TRUE; this->m_priority = 5; this->m_Completed= FALSE; } CJob::~CJob() { } BOOL CJob::AutoDelete() { return m_autoDeleteFlag; } void CJob::setAutoDelete(BOOL autoDeleteFlag) { m_autoDeleteFlag = autoDeleteFlag; } long CJob::getID() { return this->m_ID; } int CJob::getPriority() { return this->m_priority; } void CJob::setPriority(int priority) { this->m_priority = priority; }
JobExecuter.h文件：
//一个对象对应一个线程，执行任务Job class CJobExecuter { public: CJobExecuter(CMThreadedJobQ *pJobQ); virtual ~CJobExecuter(); //================================================================================================ //函数名： stop //函数描述： 停止执行任务 //输入： 无 //输出： 无 //返回： 无 //================================================================================================ void stop(); //================================================================================================ //函数名： execute //函数描述： 执行一个任务 //输入： [in] pJob 任务指针 //输出： 无 //返回： 无 //================================================================================================ void execute(CJob* pJob); static UINT ThreadFunction(LPVOID pParam); //线程函数 CMThreadedJobQ* m_pJobQ; //指向线程任务队列指针 CJob* m_pJob2Do; //指向正在执行任务的指针 int m_flag; //线程执行标记 CWinThread* m_pExecuterThread; //线程标识符 };
JobExecuter.cpp文件：
#define STOP_WORKING -1 #define KEEP_WORKING 0 CJobExecuter::CJobExecuter(CMThreadedJobQ *pJobQ) { this->m_pJobQ= pJobQ; this->m_pExecuterThread= AfxBeginThread(ThreadFunction,this); this->m_pJob2Do = NULL; this->m_flag = KEEP_WORKING; } CJobExecuter::~CJobExecuter() { if(this->m_pExecuterThread!= NULL ) { this->m_pExecuterThread->ExitInstance(); delete m_pExecuterThread; } } UINT CJobExecuter::ThreadFunction(LPVOID pParam) { CJobExecuter *pExecuter = (CJobExecuter *)pParam; pExecuter->m_flag = 1; ::Sleep(1); CSingleLock singleLock(&pExecuter->m_pJobQ->m_cs); while(pExecuter->m_flag !=STOP_WORKING ) { if(pExecuter->m_pJob2Do!= NULL) { pExecuter->m_pJob2Do->execute(); pExecuter->m_pJob2Do->m_Completed = TRUE; if(pExecuter->m_pJob2Do->AutoDelete()) delete pExecuter->m_pJob2Do; pExecuter->m_pJob2Do = NULL; } if(pExecuter->m_pJobQ == NULL) break; CSingleLock singleLock(&pExecuter->m_pJobQ->m_cs); singleLock.Lock(); if(pExecuter->m_pJobQ->getNoOfExecuter() > pExecuter->m_pJobQ->getMaxNoOfExecuter()) //CJobExecuter个数大于最大值，自动销毁 { pExecuter->stop(); singleLock.Unlock(); } else { pExecuter->m_pJobQ->addFreeJobExecuter(pExecuter); //完成任务后，添加到CMThreadedJobQ的空闲队列中 singleLock.Unlock(); pExecuter->m_pJobQ->m_pObserverThread->ResumeThread(); pExecuter->m_pExecuterThread->SuspendThread(); } } if(pExecuter->m_pJobQ != NULL) { pExecuter->m_pJobQ->deleteJobExecuter(pExecuter); } else { delete pExecuter; } return 0; } void CJobExecuter::execute(CJob* pJob) { this->m_pJob2Do = pJob; ::Sleep(0); this->m_pExecuterThread->ResumeThread(); } void CJobExecuter::stop() { this->m_flag = STOP_WORKING; this->m_pExecuterThread->ResumeThread(); }
MThreadedJobQ.h文件：
typedef CTypedPtrList< CPtrList ,CJob*>CJobQList; //线程池任务队列 class CMThreadedJobQ { public: typedef struct THNODE { CJobExecuter* pExecuter; THNODE * pNext ; } THNODE; CMThreadedJobQ(); virtual ~CMThreadedJobQ(); //================================================================================================ //函数名： deleteJobExecuter //函数描述： 删除一个JobExecuter对象 //输入： [in] pEx //输出： 无 //返回： 无 //================================================================================================ void deleteJobExecuter(CJobExecuter *pEx); //================================================================================================ //函数名： setMaxNoOfExecuter //函数描述： 设置CJobExecuter的个数 //输入： [in] value //输出： 无 //返回： 无 //================================================================================================ void setMaxNoOfExecuter(int value); //================================================================================================ //函数名： addJobExecuter //函数描述： 添加一个CJobExecuter //输入： [in] pEx //输出： 无 //返回： 无 //================================================================================================ void addJobExecuter(CJobExecuter *pEx); //================================================================================================ //函数名： getJobExecuter //函数描述： 返回一个CJobExecuter //输入： 无 //输出： 无 //返回： 处理任务的指针 //================================================================================================ CJobExecuter* getJobExecuter(); //================================================================================================ //函数名： addFreeJobExecuter //函数描述： 添加一个CJobExecuter //输入： [in] pEx //输出： 无 //返回： 无 //================================================================================================ void addFreeJobExecuter(CJobExecuter *pEx); //================================================================================================ //函数名： addJob //函数描述： 添加一个任务 //输入： [in] pJob //输出： 无 //返回： 无 //================================================================================================ void addJob(CJob *pJob); //================================================================================================ //函数名： getMaxNoOfExecuter //函数描述： 获取CJobExecuter个数的最大值 //输入： 无 //输出： 无 //返回： 无 //================================================================================================ int getMaxNoOfExecuter(); //================================================================================================ //函数名： getNoOfExecuter //函数描述： 获取当前CJobExecuter的个数 //输入： 无 //输出： 无 //返回： 无 //================================================================================================ int getNoOfExecuter(); static UINT JobObserverThreadFunction(LPVOID); //================================================================================================ //函数名： pause //函数描述： 挂起JobObserverThread线程 //输入： 无 //输出： 无 //返回： 无 //================================================================================================ void pause(); //================================================================================================ //函数名： resume //函数描述： 唤醒JobObserverThread线程 //输入： 无 //输出： 无 //返回： 无 //================================================================================================ void resume(); CWinThread* m_pObserverThread; //向空闲的executer线程添加任务的线程 CCriticalSection m_cs; //关键代码段，用于互斥 CJobQList m_jobQList; //任务队列 private : BOOL m_pause; //JobObserverThread线程运行标记 int m_MaxNoOfExecuter; //CJobExecuter最大个数 int m_NoOfExecuter; //当前CJobExecuter个数 THNODE* m_pFreeEList; //维护空闲处理任务线程的队列 THNODE* m_pAllEList; //维护所有处理任务线程的队列 };
MThreadedJobQ.cpp文件：
CMThreadedJobQ::CMThreadedJobQ() { m_MaxNoOfExecuter = 2; m_pause = FALSE; m_pObserverThread = AfxBeginThread(JobObserverThreadFunction,this); m_pFreeEList =NULL; m_NoOfExecuter =0; m_pAllEList = NULL; } CMThreadedJobQ::~CMThreadedJobQ() { THNODE* pTempNode; while (m_pAllEList != NULL) { pTempNode = m_pAllEList->pNext; delete m_pAllEList->pExecuter; delete m_pAllEList; m_pAllEList = pTempNode; } while (m_pFreeEList != NULL) { pTempNode = m_pFreeEList->pNext; delete m_pFreeEList; m_pFreeEList = pTempNode; } m_pObserverThread->ExitInstance(); delete m_pObserverThread; } void CMThreadedJobQ::pause() { this->m_pause = TRUE; } void CMThreadedJobQ::resume() { this->m_pause = FALSE; this->m_pObserverThread->ResumeThread(); } UINT CMThreadedJobQ::JobObserverThreadFunction(LPVOID pParam) { CMThreadedJobQ *pMTJQ = (CMThreadedJobQ *)pParam; CJobExecuter *pJExecuter; while(TRUE) { Sleep(100); if(pMTJQ->m_pause != TRUE) { while(!pMTJQ->m_jobQList.IsEmpty() ) { pJExecuter = pMTJQ->getJobExecuter(); if( pJExecuter!=NULL) { pMTJQ->m_cs.Lock(); pJExecuter->execute(pMTJQ->m_jobQList.GetHead()); pMTJQ->m_jobQList.RemoveHead(); AfxGetApp()->m_pMainWnd->PostMessage(REFRESH_LIST); pMTJQ->m_cs.Unlock(); } else { break; } if(pMTJQ->m_pause == TRUE) break; } } pMTJQ->m_pObserverThread->SuspendThread(); } return 0; } int CMThreadedJobQ::getNoOfExecuter() { return this->m_NoOfExecuter; } int CMThreadedJobQ::getMaxNoOfExecuter() { return this->m_MaxNoOfExecuter; } void CMThreadedJobQ::addJob(CJob *pJob) { CJob * pTempJob; CSingleLock sLock(&this->m_cs); sLock.Lock(); POSITION pos,lastPos; pos = this->m_jobQList.GetHeadPosition(); lastPos = pos; if(pos != NULL) pTempJob =this->m_jobQList.GetHead(); while(pos != NULL ) { if( pJob->getPriority() > pTempJob->getPriority()) break; lastPos = pos; pTempJob = this->m_jobQList.GetNext(pos); } if(pos == NULL) this->m_jobQList.AddTail(pJob); else this->m_jobQList.InsertBefore(lastPos,pJob); this->m_pObserverThread->ResumeThread(); sLock.Unlock(); } void CMThreadedJobQ::addFreeJobExecuter(CJobExecuter *pEx) { m_cs.Lock(); THNODE* node = new THNODE; node->pExecuter = pEx; node->pNext = this->m_pFreeEList; this->m_pFreeEList = node; m_cs.Unlock(); } CJobExecuter* CMThreadedJobQ::getJobExecuter() { THNODE *pTemp; CJobExecuter *pEx=NULL; m_cs.Lock(); if(this->m_pFreeEList != NULL) //有空闲CJobExecuter,就返回 { pTemp = this->m_pFreeEList; this->m_pFreeEList = this->m_pFreeEList->pNext; pEx = pTemp->pExecuter; delete pTemp ; m_cs.Unlock(); return pEx; } if(this->m_NoOfExecuter < this->m_MaxNoOfExecuter) //没有空闲CJobExecuter，并且当前CJobExecuter小于最大值，就生成一个新的CJobExecuter { pEx = new CJobExecuter(this); this->addJobExecuter(pEx); this->m_NoOfExecuter++; m_cs.Unlock(); return pEx; } m_cs.Unlock(); return NULL; } void CMThreadedJobQ::addJobExecuter(CJobExecuter *pEx) { m_cs.Lock(); THNODE* node = new THNODE; node->pExecuter= pEx; node->pNext = this->m_pAllEList; this->m_pAllEList = node; m_cs.Unlock(); } void CMThreadedJobQ::setMaxNoOfExecuter(int value) { this->m_cs.Lock(); if(value >1 && value <11) this->m_MaxNoOfExecuter = value; m_pObserverThread->ResumeThread(); this->m_cs.Unlock(); } void CMThreadedJobQ::deleteJobExecuter(CJobExecuter *pEx) { THNODE* pNode,*pNodeP; CSingleLock singleLock(&m_cs); singleLock.Lock(); if(this->m_pAllEList != NULL) { pNode = this->m_pAllEList; if(pNode->pExecuter == pEx ) { this->m_pAllEList = pNode->pNext; delete pNode; } else { pNodeP =pNode; pNode = pNode->pNext ; while(pNode != NULL ) { if(pNode->pExecuter== pEx ) break; pNodeP = pNode; pNode = pNode->pNext ; } if(pNode!= NULL) { pNodeP->pNext = pNode->pNext; delete pNode; } } } this->m_NoOfExecuter--; singleLock.Unlock(); pEx->stop(); Sleep(1); delete pEx; }
以上，就是该可伸缩多线程任务的主体框架，当我们工作需要实现类似这样的需要：异步执行多个不同的任务时，这个例子就是一个很好的参考例子，我研究这些代码只是为了让我在遇到这种问题的时候，可以有一个思路去思考，而不至于无从下手，仅此而已。
