基于windows多线程开发的任务执行队列设计实现实例

之前写在其他地方，转移到csdn来。

只需要生成一个任务队列执行者，并启动，就可以不断的往里面添加任务，自动在后台执行任务。而且可以方便的终止所有任务。本程序只是演示任务队列的实现方式，具体应用到项目可以根据实际情况修改。实现自己的任务类。添加自己的参数。

本站原创，谢绝转载。

#include "stdafx.h"
#include <iostream>
#include <vector>

#include <Windows.h>

class MyMutex
{
public:
        MyMutex() { InitializeCriticalSection(&m_mutexLock); }
        ~MyMutex() { DeleteCriticalSection(&m_mutexLock);  }

public:
        void  Lock(void) { EnterCriticalSection(&m_mutexLock); }
        void  Unlock(void) { LeaveCriticalSection(&m_mutexLock); }

private:
        CRITICAL_SECTION  m_mutexLock;
};




//所有任务的基类
class ITaskEvent
{
public:
        virtual ~ITaskEvent() { };

        virtual void execute() = 0;
        virtual void stop() = 0;
};

//模拟任务类1
class TaskClass1 : public ITaskEvent
{
public:
        TaskClass1(){m_isStop = false;};
        virtual ~TaskClass1(){};

        virtual void execute(){ 

                int i= 0;
                while (!m_isStop && i<10)
                {
                        Sleep(100);
                        std::cout<<"\nthis is task class 1 execute...";
                        i++;
                }
                
        };
        //终止任务
        virtual void stop(){
                m_isStop = true;
        };

private:
        boolean m_isStop;


};

//模拟任务类2
class TaskClass2 : public ITaskEvent
{
public:
        TaskClass2(){m_isStop = false;};
        virtual ~TaskClass2(){};

        virtual void execute()
        {
                int i= 0;
                while (!m_isStop && i<10)
                {
                        Sleep(100);
                        std::cout<<"\nthis is task class 2 execute...";
                        i++;
                }
        };
        //终止任务
        virtual void stop()
        {
                m_isStop = true;
        }

private:
    boolean m_isStop;

};




//执行所有任务的线程类
class TasksThread
{

        //所有的任务列表
        typedef std::vector<ITaskEvent * >        ListTaskEvent;
        

public:
        TasksThread()
        {
        };
        virtual ~TasksThread()
        {
                stop();
        };

        static DWORD WINAPI  ThreadFunc(LPVOID p)

        {
                if (p != NULL)
                {
                        TasksThread *pThis = (TasksThread *)p;
                        pThis->thread_run();
                }
                return 0;
        }

        //向线程中添加一个任务
        void   post_task(ITaskEvent * task){
                myMutex.Lock();        
                m_lstTaskEvents.push_back(task);
                myMutex.Unlock();
        };

        //开始创建线程，执行任务
        unsigned int start()
        {
                m_stop_flag = false;
                hThread = ::CreateThread(NULL, NULL, TasksThread::ThreadFunc, this, 0, &threadId);
                return 0;
        }

        


        //先停止任务，等待指定的时间，INFINITE等其自行结束
        void join(unsigned long millseconds)
        {
                stop();
                if (hThread != NULL)
                {
                        WaitForSingleObject(hThread, millseconds);
                        //TerminateThread(hThread, DEF_EXIT_CODE);//强制中止它,容易出问题
                        CloseHandle(hThread);
                }
                
        }



        //线程的执行方法
        unsigned int thread_run()
        {
                
                while (!this->m_stop_flag)
                {
                        process_tasks();
                        Sleep(10);
                        
                }
                return 0;
        };

private:
        //执行任务队列里面的任务
        void        process_tasks()
        {
                std::vector<ITaskEvent * > lst;
                {
                        myMutex.Lock();
                        m_lstTaskEvents.swap(lst);
                        myMutex.Unlock();
                }

                std::vector<ITaskEvent * >::iterator  vit = lst.begin();
                for (; vit != lst.end(); vit ++)
                {
                        if (m_stop_flag)
                        {
                                (*vit)->stop();
                                delete (*vit);                
                                continue;
                        }
                        else
                        {
                                        
                                (*vit)->execute();
                                delete (*vit);        
                        }                
                        
                }
        };

        //停止执行任务,异步停止
        void stop()
        {
                this->m_stop_flag = true;
        }

private:
        HANDLE  hThread;
        DWORD  threadId;
        ListTaskEvent               m_lstTaskEvents;
        //终止标志
        boolean m_stop_flag;
        MyMutex myMutex;
};

int _tmain(int argc, _TCHAR* argv[])
{

        //创建一个任务队列执行者，开始后，可以不断的按顺序执行加入其中的任务
        TasksThread taskThread;

        //创建几个任务
        TaskClass1 *t1 = new TaskClass1();
        TaskClass2 *t2 = new TaskClass2();

        taskThread.post_task(t1);//加入任务
        taskThread.post_task(t2);//加入任务

        //开始执行
        taskThread.start();

        //中途再加入任务
        taskThread.post_task(new TaskClass1());

        
        int a;
        std::cin>>a;
        while (a != 0)
        {
                taskThread.post_task(new TaskClass2());//测试不断的加入新的任务
                std::cin>>a;

        }


        taskThread.join(INFINITE);//发终止命令后，一直等待到它结束
        //taskThread.join(100);//发终止命令后，等待100毫秒，让其自行结束

        return 0;
}