设计模式在项目中的应用之线程池

前言

设计模式分为三大类：
创建型模式五种：简单工厂模式、抽象工厂模式、单实例模式、建造者模式、原型模式
结构型模式七种：适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为型模式十一种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
额外几种模式：MVC模式、线程池模式、状态机模式
写一手好的代码，如同做生意，让自己的店铺整洁有序，可以让人赏心悦目、让店铺客源滚滚。
线程池对线程统一管理，隐藏内部实现，提供对外统一接口，可以解决代码混乱和cpu使用浪费的情况。

整体设计

UML类图

对外接口类：TaskBase
线程池类：ThreadPool
具体执行者：CommandTask和FlowTask
具体实现
TaskBase接口函数说明
run:继承者需要在线程中具体执行的任务
stop:线程池中的任务被终止后触发
deleteTask:还未执行的任务被删除时触发
ThreadPool函数说明
start:用户开始时执行
stop:停止线程池的运行
stopTask:终止线程池内部正在运行和未运行的任务
addTask:增加新的任务
线程池的执行结果如何提供
任务的人为终止，是靠回调机制触发具体执行者CommandTask和FlowTask中的当前执行中和未执行的任务，并将结果放入结果队列。
正常任务的执行结果直接放入结果队列。

线程池的具体实现

//
// Created by lizong on 2021/11/18.
//

#include <iostream>
#include "ThreadPool.h"

ThreadPool::ThreadPool(uint16_t nMaxThread)
        :m_MaxThreadNum(nMaxThread)
        , m_ThreadStatus(true)
{

}

ThreadPool::~ThreadPool()
{
    for (std::thread& workThread : this->m_ThreadVec)
    {
        if (workThread.joinable()) {
            workThread.join();
        }
    }
}
/*
* 添加任务到任务队列
*/
void ThreadPool::addTask(std::shared_ptr<TaskBase> pTask)
{
    if (m_ThreadStatus) {
        throw std::runtime_error("workers stop");
    }
    std::unique_lock<std::mutex> lock(this->m_QueueMutex);
    m_TaskQueue.emplace(pTask);
    m_Condition.notify_one();
}

uint32_t ThreadPool::GetTaskNum()
{
    return m_TaskQueue.size() + m_TaskWorkingQueue.size();
}

void ThreadPool::stopTask()
{
    std::unique_lock<std::mutex> lock(this->m_QueueMutex);
    while(m_TaskWorkingQueue.size() > 0)
    {
        std::shared_ptr<TaskBase> pTask = this->m_TaskWorkingQueue.front();
        pTask->stop();//终止正在执行的 防阻塞
        this->m_TaskWorkingQueue.pop();
    }

    while(m_TaskQueue.size() > 0)
    {
        std::shared_ptr<TaskBase> pTask = this->m_TaskQueue.front();
        pTask->deleteTask();//删除未开始的，触发其返回逻辑
        this->m_TaskQueue.pop();
    }
}

void ThreadPool::start() {
    //启动的时候就要创建线程
    auto maxNum = std::thread::hardware_concurrency();
    //获取当前操作系统中CPU的核心数量 根据核心数量来设置 最大工作线程的并发数量
    m_MaxThreadNum = m_MaxThreadNum > maxNum ? maxNum : m_MaxThreadNum;
    //创建工作线程池
    m_ThreadStatus = false;
    for (int i = 0; i < m_MaxThreadNum; i++)
    {
        //emplace_back 参数化 直接构造thread
        m_ThreadVec.emplace_back([this] {
            while (true)
            {
                std::unique_lock<std::mutex> lock(this->m_QueueMutex);
                //此处锁被自动释放，wait成功后锁自动打开
                this->m_Condition.wait(lock, [this]() {return this->m_ThreadStatus || !this->m_TaskQueue.empty(); });
                if (this->m_ThreadStatus && this->m_ThreadVec.empty())
                {
                    return;
                }
                //获取队列头部的任务
                std::shared_ptr<TaskBase> pTask = this->m_TaskQueue.front();
                //任务出队
                this->m_TaskQueue.pop();
                this->m_TaskWorkingQueue.push(pTask);
                //执行工作
                lock.unlock();//此处需要释放，防止线程卡死

                if(pTask)
                {
                    pTask->run(); //此处非阻塞更合理
                }

                lock.lock();
                if(this->m_TaskWorkingQueue.size())
                {
                    this->m_TaskWorkingQueue.pop();
                }
                lock.unlock();
            }
        });
    }
}

void ThreadPool::stop() {
    std::unique_lock<std::mutex> lock(this->m_QueueMutex);
    this->m_ThreadStatus = true;
    //通知所有线程起来工作 然后退出
    this->m_Condition.notify_all();
    //等待所有线程工作完毕
    for (std::thread& worker : this->m_ThreadVec)
    {
        if (worker.joinable()) {
            worker.join();
        }
    }
}

知识点延伸
这种模式的线程池和是否有些类似观察者模式？
观察者模式定义了对象间的一种一对多的组合关系，以便一个对象的状态发生变化时，所有依赖于他的对象都得到通知并自动刷新。在这里线程池如同被观察者，接口实现类如同观察者，观察线程池的执行状态。但是从具体实现来看，其实观察者模式主要是为了解耦两者，需要实现增加和删除观察者对象功能，并且支持多个一个对多关系，Qt中的信号槽机制就是使用了观察者模式。