C++ 簡單的任務隊列

任務隊列是指能夠實現任務在多線程間安全傳遞的先入先出的隊列。

任務是指組合了數據和操作的對象，這里面定義為CTask類的對象。

 

任務的實現：

Task.cpp

#include "stdafx.h"
#include "Task.h"
#include <iostream>
using namespace std;

CTask::CTask(int* nCount)
{
    m_nCount = nCount;
}

CTask::~CTask()
{
}

void CTask::DoWork()
{
    (*m_nCount)++;

    cout << "Count = " << *m_nCount << endl;
}

 

Task.h

#pragma once
class CTask
{
    int* m_nCount;
public:
    CTask(int* nCount);
    ~CTask();

    void DoWork();
};

 

隊列的實現：

TaskQueue.cpp

#include "stdafx.h"
#include "TaskQueue.h"


CTaskQueue::CTaskQueue()
{
}


CTaskQueue::~CTaskQueue()
{
}


//工作線程
void CTaskQueue::WorkThread()
{
    while (m_bIsStart)
    {
        if (!m_taskQueue.empty())
        {
            CTask* it = m_taskQueue.front();
            it->DoWork();
            m_taskQueue.pop();
            delete it;
        }
    }
}

//向任務隊列添加任務
bool CTaskQueue::Push(CTask* task)
{
    if (task == nullptr)
    {
        return false;
    }

    m_mutex.lock();
    m_taskQueue.push(task);
    m_mutex.unlock();

    return true;
}
//從任務隊列獲取任務
CTask* CTaskQueue::Pop()
{
    CTask* it = nullptr;

    m_mutex.lock();
    if (!m_taskQueue.empty())
    {
        it = m_taskQueue.front();
        m_taskQueue.pop();
    }
    m_mutex.unlock();
    return it;
}

bool CTaskQueue::Start()
{
    if (m_bIsStart)
    {
        return false;
    }
    m_bIsStart = true;
    m_thread = std::thread(&CTaskQueue::WorkThread, this);

    return true;
}

void CTaskQueue::Stop()
{
    m_bIsStart = false;
    m_thread.join();
}

 

TaskQueue.h

#pragma once
#include "Task.h"
#include <queue>
#include <mutex>
#include <thread>

class CTaskQueue
{
public:
    CTaskQueue();
    ~CTaskQueue();

private:
    std::queue<CTask*> m_taskQueue;  //任務隊列
    std::thread m_thread;
    std::mutex m_mutex;
    bool m_bIsStart;   //線程是否開啟

public:
    //工作線程
    void WorkThread();  

    //向任務隊列添加任務
    bool Push(CTask* task);
    //從任務隊列獲取任務
    CTask* Pop();

    //開啟線程
    bool Start();
    //終止線程
    void Stop();
};

 

 

測試demo：

// TaskQueue.cpp : 定義控制台應用程序的入口點。
//

#include "stdafx.h"
#include "TaskQueue.h"
#include "Task.h"

void MyWorkTask1(CTaskQueue* pTaskQueue, int* nCount)
{
    for (size_t i = 0; i < 20; i++)
    {    
        CTask* task = new CTask(nCount);
        pTaskQueue->Push(task);
    }
}

void MyWorkTask2(CTaskQueue* pTaskQueue, int* nCount)
{
    for (size_t i = 0; i < 20; i++)
    {
        CTask* task = new CTask(nCount);
        pTaskQueue->Push(task);
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    CTaskQueue* pTaskQueue = new CTaskQueue();
    pTaskQueue->Start();

    int* nCount = new  int(0);

    std::thread thread1(&MyWorkTask1, pTaskQueue, nCount);
    std::thread thread2(&MyWorkTask2, pTaskQueue, nCount);

    //等待線程結束
    if (thread1.joinable())
    {
        thread1.join();
    }
    if (thread2.joinable())
    {
        thread2.join();
    }

    system("pause");
    return 0;
}