c++实现简单线程池代码

目录

• ​​完整代码​​

• ​​TaskPool.cpp​​
• ​​TaskPool.h​​
• ​​main.cpp​​

完整代码

TaskPool.cpp

//
// Created by LENOVO on 2021/10/25.
//

#include "TaskPool.h"
#include <functional>

std::mutex printMutex;

TaskPool::TaskPool() : m_bRunning(false)
{

}

TaskPool::~TaskPool()
{
    removeAllTasks();
}

void TaskPool::init(int threadNum/*= 5*/)
{
    if (threadNum <= 0)
        threadNum = 5;
    m_bRunning = true;

    for (int i = 0; i < threadNum; i++) {
        std::shared_ptr<std::thread> spThread;
        // 这个bind含义是啥
        spThread.reset(new std::thread(std::bind(&TaskPool::threadFunc, this)));
        {
            std::lock_guard<std::mutex> guard(printMutex);
            std::cout << "Init a thread, id: "<< spThread->get_id() << std::endl;
        }
        m_threads.push_back(spThread);
    }
}

void TaskPool::stop()
{
    m_bRunning = false;
    // 通知所有线程，不运行了
    m_cv.notify_all();

    // 等待所有线程退出
    for (auto& it : m_threads) {
        if (it->joinable())
            it->join();
    }
}

void TaskPool::addTask(Task *task)
{
    std::shared_ptr<Task> spTask;
    spTask.reset(task);

    {// 将task加入队列是互斥的
        std::lock_guard<std::mutex> guard(m_mutexList);
        m_taskList.push_back(spTask);
    }

    {
        std::lock_guard<std::mutex> guard(printMutex);
        std::cout << "add a Task, id: " << spTask->getID() << ", thread id is: " << std::this_thread::get_id() << std::endl;
    }
    // 通知一个线程的threadFunc
    m_cv.notify_one();
}

void TaskPool::removeAllTasks()
{
    {// 需要先互斥地将指向taskList的ptr重置，然后将整个taskList资源clead
        std::lock_guard<std::mutex> guard(m_mutexList);
        for (auto& it : m_taskList) {
            it.reset();
        }
        m_taskList.clear();
    }
}

void TaskPool::threadFunc()
{
    std::shared_ptr<Task> spTask;
    while (true) {
        // 获取task的过程是互斥的
        { // 减少锁的粒度
            std::unique_lock<std::mutex> guard(m_mutexList);
            // 如果任务队列为空,那么就一直wait，等待线程被唤醒加入到队列中
            while (m_taskList.empty()) {
                if (!m_bRunning)
                    break;
                // 如果获得了互斥锁，但是条件不满足
                // wait()会释放锁，挂起当前线程
                // 条件变量发生变化的时候，wait()将环型挂起的线程并获得锁
                m_cv.wait(guard);
            }

            if (!m_bRunning)
                break;
            // 获取队头task
            spTask = m_taskList.front();
            m_taskList.pop_front();
        }
        // 如果队列为空，则重新进行尝试获取
        if (spTask == NULL)
            continue;
        // 否则，执行task任务
        spTask->doIt();
        // 完成之后，将指针重置
        spTask.reset();
    }
    std::lock_guard<std::mutex> guard(printMutex);
    std::cout << "exit thread , threadID:" << std::this_thread::get_id() << std::endl;
}

TaskPool.h

//
// Created by LENOVO on 2021/10/25.
//

#ifndef UNTITLED_TASKPOOL_H
#define UNTITLED_TASKPOOL_H

#include<thread>
#include<mutex>
#include<condition_variable>
#include<list>
#include<vector>
#include<memory>
#include<iostream>

extern std::mutex printMutex;

class Task{
private:
    unsigned int id;
public:
    Task(unsigned int ID)
    {
        id = ID;
    }
    virtual void doIt()
    {
        std::lock_guard<std::mutex> guard(printMutex);
        std::cout << "handle a task ,TaskID is: "<< id << ", thradID is:" << std::this_thread::get_id() << std::endl;
    }
    virtual ~Task()
    {
        std::lock_guard<std::mutex> guard(printMutex);
        std::cout << "a task destructed , TaskID is: "<< id << ", thradID is:" << std::this_thread::get_id() << std::endl;
    }
    unsigned int getID()
    {
        return id;
    }
};

class TaskPool final{
public:
    TaskPool();
    ~TaskPool();
    TaskPool(const TaskPool& rhs) = delete;
    TaskPool& operator=(const TaskPool& rhs) = delete;

public:
    // 初始化线程
    void init(int threadNum = 5);
    // 通知所有线程结束运行，并等待所有线程运行结束
    void stop();

    void addTask(Task* task);
    void removeAllTasks();

private:
    void threadFunc();

private:
    std::list<std::shared_ptr<Task>>            m_taskList;
    std::mutex                                  m_mutexList;
    std::condition_variable                     m_cv;
    bool                                        m_bRunning;
    std::vector<std::shared_ptr<std::thread>>   m_threads;
};

#endif //UNTITLED_TASKPOOL_H

main.cpp

#include<chrono>
#include "TaskPool.h"

int main()
{
    TaskPool threadPool;
    threadPool.init();
    Task* task = NULL;
    for (int i = 0; i < 10; i++) {
        task = new Task(i);
        threadPool.addTask(task);
    }
    std::this_thread::sleep_for(std::chrono::seconds(5));

    threadPool.stop();

    return 0;
}