C++线程池,仿照苏丙榅老师的线程池

苏丙榲老师用的是linux下的pthread,我把它改造成了C++11版的
原文链接在:手写线程池 - C改C++版 | 爱编程的大丙 (subingwen.cn)
2021-7-20 这版的能解决问题,能运行,但没经过长时间的测试;1.后面需要对线程回收,2.工作者线程的退出,3.上锁的地方再优化

• 注意点:工作者线程上锁的地方,加了第二参数

// 此处添加第二参数
std::unique_lock<std::mutex> unique_locker(p_pool->mutex_locker, std::try_to_lock);
p_pool->condition_not_empty.wait(unique_locker, [&](){return p_pool->flag_ready;});                p_pool->flag_ready = false;

• task.h

#ifndef TASK_H
#define TASK_H
#include <queue>
#include <mutex>
#include <opencv2/opencv.hpp>

// 定义任务结构体
//using callback = void(*)(void*);
using callback = void (*)(const std::string& file_name, const cv::Mat& mat_org_rgb);
struct Task
{
    Task()
    {
        function = nullptr;
    }
    Task(callback f, const std::string& file_name_in, const cv::Mat& mat_org_rgb_in):
        function(f), file_name(file_name_in){mat = mat_org_rgb_in.clone();}
    // cpy ctr
    Task(const Task& task){
        function = task.function;
        file_name = task.file_name;
        mat = task.mat.clone();
    }
    // assigiment
    Task& operator=(Task& task){
        do{
            if(this == &task)
                break;
            function = task.function;
            file_name = task.file_name;
            mat = task.mat.clone();
        }while(0);
        return *this;
    }

    // core callback function
    callback function;
    // core data
    std::string file_name;
    cv::Mat mat;
};

// 任务队列
class TaskQueue
{
public:
    TaskQueue();
    ~TaskQueue();

    // 添加任务
    void addTask(const Task& task);
    //void addTask(callback func, void* arg);

    // 取出一个任务
    Task takeTask();

    // 获取当前队列中任务个数
    inline int taskNumber()
    {
        return m_queue.size();
    }

private:
    std::mutex m_mutex;    // 互斥锁
    std::queue<Task> m_queue;   // 任务队列
};

#endif // TASK_H

• task.cpp

#include "task.h"
void save_file(const std::string& file_name, const cv::Mat& mat_org_rgb)
{
    cv::imwrite(file_name, mat_org_rgb);
}
TaskQueue::TaskQueue()
{
}

TaskQueue::~TaskQueue()
{
}

void TaskQueue::addTask(const Task& task)
{
    std::lock_guard<std::mutex> lock_guard(m_mutex);
    m_queue.push(task);
}

//void TaskQueue::addTask(callback func, const std::string& file_name_in, const cv::Mat& mat_org_rgb_in)
//{
//    std::lock_guard<std::mutex> lock_guard(m_mutex);

////    task.function = func;
////    task.file_name = file_name_in;
////    task.mat = mat_org_rgb_in;
//    Task task(func, file_name_in, mat_org_rgb_in);
//    m_queue.push(task);
//}

Task TaskQueue::takeTask()
{
    Task t;
    std::lock_guard<std::mutex> lock_guard(m_mutex);
    if (m_queue.size() > 0)
    {
        t = m_queue.front();
        m_queue.pop();
    }
    return t;
}

• thread_pool.h

#ifndef THREADPOOL_H
#define THREADPOOL_H
#include "thread_pool/task.h"
#include <condition_variable>
using std::cout; using std::endl;

class ThreadPool
{
public:
    ThreadPool(int min, int max);
    ~ThreadPool();

    // 添加任务
    void addTask(Task task);
    // 获取忙线程的个数
    int getBusyNumber();
    // 获取活着的线程个数
    int getAliveNumber();

private:
    // 工作的线程的任务函数
    static void* worker(void* arg);
    // 管理者线程的任务函数
    static void* manager(void* arg);    

private:
    std::mutex mutex_locker;
    std::condition_variable condition_not_empty;
    bool flag_ready{false};

    std::vector<std::thread> vec_thread;

    std::thread thread_manager;

    TaskQueue* m_taskQ;
    int m_minNum;
    int m_maxNum;
    int m_busyNum;
    int m_aliveNum;
    int m_exitNum;
    bool m_shutdown = false;
};

#endif // THREADPOOL_H

• hread_pool.cpp

#include "threadpool.h"
#include <QDebug>

ThreadPool::ThreadPool(int minNum, int maxNum)
{
    // 实例化任务队列
    m_taskQ = new TaskQueue;
    do {
        // 初始化线程池
        m_minNum = minNum;
        m_maxNum = maxNum;
        m_busyNum = 0;
        m_aliveNum = minNum;

        /////////////////// 创建线程 //////////////////
        // 根据最小线程个数, 创建线程
        for (int i = 0; i < minNum; ++i)
        {
            std::thread t = std::thread(worker, this);
            vec_thread.emplace_back(std::move(t));
            //cout << "create and move one thread " << "i: " << i << endl;
        }
        cout << "cotr run" << endl;

        // 创建管理者线程, 1个
        thread_manager = std::move(std::thread(manager, this));
    } while (0);
}

ThreadPool::~ThreadPool()
{
    m_shutdown = 1;

    // 回收管理者线程
    if(thread_manager.joinable())   thread_manager.join();

    // 唤醒所有消费者线程
    for (int i = 0; i < m_aliveNum; ++i)
    {
        {
            std::lock_guard<std::mutex> lock_guarder(mutex_locker);
            flag_ready = true;
        }
        condition_not_empty.notify_one();
    }

    // 回收工作者线程
    for(std::vector<std::thread>::iterator it = vec_thread.begin(); it != vec_thread.end(); ++it)
    {
        if(it->joinable())
        {
            it->join();
            vec_thread.erase(it);
        }
    }

    if (m_taskQ) delete m_taskQ;
}

void ThreadPool::addTask(Task task)
{
    if (m_shutdown)
    {
        return;
    }
    // 添加任务，不需要加锁，任务队列中有锁
    m_taskQ->addTask(task);
    // 唤醒工作的线程
    {
        std::lock_guard<std::mutex> lock_guarder(mutex_locker);
        flag_ready = true;
    }
    condition_not_empty.notify_one();
}

int ThreadPool::getAliveNumber()
{
    int threadNum = 0;
    {
        std::lock_guard<std::mutex> lock_guarder(mutex_locker);
        threadNum = m_aliveNum;
    }
    return threadNum;
}

int ThreadPool::getBusyNumber()
{
    int busyNum = 0;
    {
        std::lock_guard<std::mutex> lock_guarder(mutex_locker);
        busyNum = m_busyNum;
    }
    return busyNum;
}


// 工作线程任务函数
void* ThreadPool::worker(void* arg)
{
    ThreadPool* p_pool = static_cast<ThreadPool*>(arg);
    // 一直不停的工作
    while (true)
    {
        cout << "while run" << endl;
        // 访问任务队列(共享资源)加锁
        p_pool->mutex_locker.lock();
        cout << "get locker" << endl;
        // 判断任务队列是否为空, 如果为空工作线程阻塞
        while (p_pool->m_taskQ->taskNumber() == 0 && !p_pool->m_shutdown)
        {
            std::cout << "thread " << std::this_thread::get_id() << " waiting..." << std::endl;
            // 阻塞线程
            {
                // 此处添加第二参数
                std::unique_lock<std::mutex> unique_locker(p_pool->mutex_locker, std::try_to_lock);
                p_pool->condition_not_empty.wait(unique_locker, [&](){return p_pool->flag_ready;});                p_pool->flag_ready = false;
            }
            // 解除阻塞之后, 判断是否要销毁线程
            if (p_pool->m_exitNum > 0)
            {
                p_pool->m_exitNum--;
                if (p_pool->m_aliveNum > p_pool->m_minNum)
                {
                    p_pool->m_aliveNum--;
                    p_pool->mutex_locker.unlock();
                    cout << "m_exitNum: " << p_pool->m_exitNum << endl;
                    return nullptr;
                    //p_pool->threadExit();
                }
            }
        }
        // 判断线程池是否被关闭了
        if (p_pool->m_shutdown)
        {
            p_pool->mutex_locker.unlock();
            //p_pool->threadExit();
        }

        // 从任务队列中取出一个任务
        Task task = p_pool->m_taskQ->takeTask();
        // 工作的线程+1
        p_pool->m_busyNum++;
        // 线程池解锁
        p_pool->mutex_locker.unlock();
        // 执行任务
        std::cout << "thread " << std::this_thread::get_id() << " start working..." << std::endl;
        task.function(task.file_name, task.mat);

        // 任务处理结束
        std::cout << "thread " << std::this_thread::get_id() << " end working..." << std::endl;
        {
            std::lock_guard<std::mutex> lock_guarder(p_pool->mutex_locker);
            p_pool->m_busyNum--;
        }
    }

    return nullptr;
}


// 管理者线程任务函数
void* ThreadPool::manager(void* arg)
{
    ThreadPool* p_pool = static_cast<ThreadPool*>(arg);
    // 如果线程池没有关闭, 就一直检测
    while (!p_pool->m_shutdown)
    {
        // 每隔5s检测一次
        std::this_thread::sleep_for(std::chrono::seconds(5));
        // 取出线程池中的任务数和线程数量
        // 取出工作的线程池数量
        int queueSize = -1;
        int liveNum = -1;
        int busyNum = -1;
        {
            std::lock_guard<std::mutex> lock_guarder(p_pool->mutex_locker);
            queueSize = p_pool->m_taskQ->taskNumber();
            liveNum = p_pool->m_aliveNum;
            busyNum = p_pool->m_busyNum;
        }

        // 创建线程
        const int NUMBER = 2;
        // 当前任务个数>存活的线程数 && 存活的线程数<最大线程个数
        if (queueSize > liveNum && liveNum < p_pool->m_maxNum)
        {
            // 线程池加锁
            {
                std::lock_guard<std::mutex> lock_guarder(p_pool->mutex_locker);
                int num = 0;
                for (int i = 0; i < p_pool->m_maxNum && num < NUMBER
                    && p_pool->m_aliveNum < p_pool->m_maxNum; ++i)
                {
                    p_pool->vec_thread.emplace_back(std::move(std::thread(ThreadPool::worker, p_pool)));
                    num++;
                    p_pool->m_aliveNum++;

                }
            }
        }

        // 销毁多余的线程
        // 忙线程*2 < 存活的线程数目 && 存活的线程数 > 最小线程数量
        if (busyNum * 2 < liveNum && liveNum > p_pool->m_minNum)
        {
            {
                std::lock_guard<std::mutex> lock_guarder(p_pool->mutex_locker);
                p_pool->m_exitNum = NUMBER;
            }
            for (int i = 0; i < NUMBER; ++i)
            {
                {
                    std::lock_guard<std::mutex> lock_guarder(p_pool->mutex_locker);
                    p_pool->flag_ready = true;
                }
                p_pool->condition_not_empty.notify_one();
            }
        }
    }

    // 回收工作者线程
    for(std::vector<std::thread>::iterator it = p_pool->vec_thread.begin(); it != p_pool->vec_thread.end(); ++it)
    {
        if(it->joinable())
        {
            it->join();
            p_pool->vec_thread.erase(it);
        }
    }

    return nullptr;
}