dl_thread_task.h

浏览该文件的文档.

#pragma once
 
#include <mutex>
 
#include "system/dl_thread.h"
 
namespace dl
{
 
    enum class QueueMode
    {
        FIFO,
        FILO,
    };

template<typename T>
class MultiThreadTask
{
public:
 
    using FnDoTask = std::function<void(const T&)>;
    
    void Init(FnDoTask fn_do_task,
        QueueMode mode = QueueMode::FIFO, 
        size_t thread_num = (size_t)std::thread::hardware_concurrency())
    {
        _mutexTask.lock();
        _vecTaskTemp.clear();
        _vecTask.clear();
        _mutexTask.unlock();
 
        _fnDoTask = fn_do_task;
        _bEnd = false;
        _mode = mode;
 
        _allThread.resize(thread_num);
        for (auto& iter : _allThread)
        {
            iter = g_thread->Create();
            iter->Start(std::bind(&MultiThreadTask::_thread_task, this), nullptr);
        }
    }

    void AddTask(const T& task)
    {
        if (_mutexTask.try_lock())
        {
            _vecTask.splice(_vecTask.begin(), _vecTaskTemp);
            _vecTask.push_back(task);
            _mutexTask.unlock();
            return;
        }
        _vecTaskTemp.push_back(task);
    }

    void ClearTask()
    {
        _mutexTask.lock();
        _vecTaskTemp.clear();
        _vecTask.clear();
        _mutexTask.unlock();
    }

    void Wait()
    {
        while (!_bEnd)
        {
            _mutexTask.lock();
            if (_vecTask.empty())
            {
                _mutexTask.unlock();
                break;
            }
            _mutexTask.unlock();
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
    }
 
    ~MultiThreadTask()
    {
        _bEnd = true;
        for (auto& iter : _allThread)
        {
            delete iter;
        }
    }
private:
    std::list<T> _vecTaskTemp; // 当前任务临时队列
    std::list<T> _vecTask; // 当前任务
    std::mutex _mutexTask;
    FnDoTask _fnDoTask;
    std::vector<Thread*> _allThread;
    std::atomic_bool _bEnd;
    QueueMode _mode;
 
    void _thread_task()
    {
        while (!_bEnd)
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
            _mutexTask.lock();
            if (_vecTask.empty())
            {
                _mutexTask.unlock();
                continue;
            }
            T task;
            if (_mode == QueueMode::FIFO)
            {
                task = _vecTask.front();
                _vecTask.pop_front();
            }
            else
            {
                task = _vecTask.back();
                _vecTask.pop_back();
            }
            _mutexTask.unlock();
 
            _fnDoTask(task);
        }
    }
};
}