可伸缩多线程任务队列

最新推荐文章于 2024-08-13 18:48:31 发布
最新推荐文章于 2024-08-13 18:48:31 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： C++ 文章标签： 任务队列

在我们的工作中，我们经常需要异步执行一些任务，下面介绍的这个可伸缩多线程队列，可满足我们的需求。

　　出自：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;
}
复制代码

　　以上，就是该可伸缩多线程任务的主体框架，当我们工作需要实现类似这样的需要：异步执行多个不同的任务时，这个例子就是一个很好的参考例子，我研究这些代码只是为了让我在遇到这种问题的时候，可以有一个思路去思考，而不至于无从下手，仅此而已。

一叶飘舟
关注
专栏目录
自适应多线程可伸缩的生产者消费者队列服务（五）
s011803的专栏
06-11 366
本节将讲解剩下核心代码的实现本教程面向于Java及队列的入门者，用最简单的方式实现了生产者-消费者队列，通过分离数据生成（生产者）与数据处理（消费者），利用共享队列协调，有效提升系统并发处理能力与资源利用率，是多线程环境下数据共享的经典解决方案。在Java中，结合Spring Boot、Redis和Redisson可快速构建高效稳定的消息队列系统。
多线程任务队列
12-27
简单的多线程任务队列
Java中的多线程优化：如何通过线程池与任务队列提升系统性能
最新发布
微赚淘客系统开发者博客
08-13 648
本文将深入探讨如何通过线程池与任务队列优化Java中的多线程性能，提供具体的实现方案和优化建议。了解不同类型的任务队列、配置线程池参数、监控线程池状态以及处理线程池的高级特性，都是优化系统性能的关键。线程池是一种用于管理线程的机制，它维护一组线程，供多个任务共享。线程池通过复用线程来减少线程创建和销毁的开销，提高系统的性能。：使用JMX或其他监控工具实时监控线程池的状态，如活动线程数、任务队列长度、线程池大小等。：根据实际负载动态调整线程池的核心线程数和最大线程数，以适应系统负载的变化。
【笔记】多线程和任务队列
Finks
01-21 188
python 启用多线程： from therading import Thread t = Thread(target=task1, args=()) t.start() 例如： def task1(): for i in range(5): time.sleep(1) print('task 1') def task2(string): ...
JAVA自适应多线程可伸缩的生产者消费者队列服务示例代码
06-13
其中，可伸缩队列作为现代分布式系统的关键组件之一，扮演着连接生产者与消费者、平滑处理峰值流量、实现异步处理的重要角色。具体实现详见blog：https://blog.csdn.net/s011803/category_12695707.html
线程池（可伸缩任务队列）demo.rar
05-27
线程池是一种在多线程编程中非常重要的概念，它是一种线程管理机制，通过预先创建并维护一组可重用线程来执行一系列任务。在C++中，线程池可以提高程序性能，减少线程的创建和销毁开销，同时提供了一种灵活的方式来...
实现JAVA可伸缩生产者消费者队列服务的详细代码示例
资源摘要信息:"JAVA自适应多线程可伸缩的生产者消费者队列服务示例代码" Java自适应多线程可伸缩的生产者消费者队列服务示例代码，是一项重要的系统设计实现，特别适用于云计算和大数据环境。在这个环境下，系统的...
Spring 异步多线程动态任务处理的使用心得
07-27
本文将深入探讨在Spring中如何利用多线程和动态任务来实现异步处理，并分享一些实践心得。 首先，我们要理解Spring的异步处理机制。Spring通过`@Async`注解实现了方法级别的异步执行。当一个带有`@Async`的方法被...
iOS中多线程知识总结：进程、线程、GCD、串行队列、并行队列、全局队列、主线程队列、同步任务、异步任务等
JacobKong的博客
08-22 4088
iOS中多线程知识总结：进程、线程、GCD、串行队列、并行队列、全局队列、主线程队列、同步任务、异步任务等（有示例代码）进程正在运行中的程序被称作进程，负责程序运行的内存分配;每一个进程都有自己独立的虚拟内存空间。线程进程中的一个对立的执行路径被称为线程，一个进程中至少包含一条线程，该线程被称为主线程。多线程多创建一条或者多条线程的，目的就是为了开启一条新的执行路径，运行指定的代码，与主线程中的代码
多线程 + 队列
gklcsdn的博客
04-09 170
文章目录 import re import time import requests from threading import Thread from queue import Queue class Spider(Thread): def __init__(self, url_queue): Thread.__init__(self) self.u...
java 可伸缩阻塞队列实现
ah6869的博客
07-05 225
最近一年多写的最虐心的代码。必须好好复习java并发了。搞了一晚上终于测试都跑通过了，特此纪念，以资鼓励! import java.util.ArrayList; import java.util.List; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.locks...
【多线程】线程池中的队列有哪些，应该如何选择
qq_39666711的博客
07-17 1679
线程池中的队列是线程池的重要组成部分，用于存放待执行的任务。在Java中，线程池常用的队列类型包括无界队列、有界队列、直接提交队列（SynchronousQueue）、优先级队列等。
java--多线程队列(Queue)、使用/教程/实例
weixin_50492747的博客
06-15 2253
包括：DelayQueue，ConcurrentLinkedQueue，BlockingQueue。
SECS/GEM300需要实现哪些内容
SECS/GEM
02-09 4818
GEM300包含E4、E5、E30、E37、E39、E40、E84、E87、E90、E94、E116等。GEM300实现设备全自动化，也是金南瓜已经全面支持功能，作为国内首家和最好的300mm标准软件。1. 作用是控制作业，包括队列、开始、暂停、继续、完成等等。2. 包括队列、开始、暂停、继续、完成等等。3. 控制设备run to run功能。CJob全称Conrtol Job。PJob全称Process Job。3. 控制作业状态的实时状态。2. 了解设备的实时作业状态。1. 控制设备作业的控制。
CTypedPtrList 操作
04-07 481
double CTestView::GetVal(CString name) { double temp = -999999; // Dump the list elements to the debug window. POSITION pos = pSeriesList->GetHeadPosition(); for (int i = 0; i < pSeriesList->GetCount(); i++) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值