C++实现一个简洁的线程池示例

1.前言

在多线程编程中，线程池是提高系统性能和响应速度的重要手段。本文将展示如何在C++中实现一个简易的线程池，并分析其工作机制。

2.线程池核心代码

2.1 ThreadPool.h
 

#pragma once
#include <iostream>
#include <mutex>
#include <thread>
#include <queue>
#include <condition_variable>
#include <chrono>
#include <vector>
using namespace std;

//每次创建和退出线程的个数
const int NUME = 2;
//回调函数类型
using callback = void(*)(void*);
//任务类
class Task
{
public:
    Task();
    Task(callback func, void* arg);

    callback function;
    void* arg;
};
//任务队列类
class TaskQueue
{
public:
    TaskQueue();
    ~TaskQueue();

    //添加任务
    void AddTask(Task task);
    void AddTask(callback func, void* arg);
    //取出任务
    Task PopTask();

    inline int CurTaskNum();
private:
    mutex m_mutex;
    queue<Task> m_taskQueue;
};

//线程池类
class ThreadPool
{
public:
    ThreadPool(int min, int max);
    ~ThreadPool();

    //添加任务
    void addTask(Task task);
    void addTask(callback fun, void* arg);
    int getBusyNumber();
    int getAliveNumber();
private:
    static void worker(ThreadPool* pool);
    static void manager(ThreadPool* pool);
private:
    mutex m_lock;
    condition_variable m_notEmpty;
    vector<thread> m_threads;
    thread m_manager;
    TaskQueue* m_taskQueue;
    int m_minNum;
    int m_maxNum;
    int m_busyNum;
    int m_aliveNum;
    int exitNum;
    bool m_shutdown = false;
};

2.2 ThreadPool.cpp
 

#include "ThreadPool.h"
Task::Task():function(nullptr),arg(nullptr)
{}
Task::Task(callback func, void* arg) :function(func), arg(arg)
{}

TaskQueue::TaskQueue() {}

TaskQueue::~TaskQueue() {}

void TaskQueue::AddTask(Task task)
{
    lock_guard<mutex> lock(m_mutex);
    m_taskQueue.push(task);
}

void TaskQueue::AddTask(callback func, void* arg)
{
    lock_guard<mutex> lock(m_mutex);
    Task task(func, arg);
    m_taskQueue.push(task);
}

Task TaskQueue::PopTask()
{
    Task t;
    lock_guard<mutex> lock(m_mutex);
    if (m_taskQueue.size() > 0)
    {
        t = m_taskQueue.front();
        m_taskQueue.pop();
    }
    return t;
}

inline int TaskQueue::CurTaskNum()
{
    return static_cast<int>(this->m_taskQueue.size());
}

ThreadPool::ThreadPool(int min, int max)
{
    m_taskQueue = new TaskQueue();
    do {
        //初始化参数
        m_minNum = min;
        m_maxNum = max;
        m_busyNum = 0;
        m_aliveNum = min;
        //初始化线程数组
        m_threads.resize(m_maxNum);

        //创建线程
        for (int i = 0; i < m_minNum; i++)
        {
            m_threads[i] = thread(worker, this);
        }
        //创建管理者线程
        m_manager = thread(manager, this);
    } while (0);
}

ThreadPool::~ThreadPool()
{
    //关闭线程池
    m_shutdown = true;
    //回收管理者线程
    if (m_manager.joinable()) {
        m_manager.join();
    }
    //唤醒所有线程
    m_notEmpty.notify_all();

    //回收工作线程
    for (auto& th : m_thread