线程池的工作原理及C++实现

本文的笔记来自于b站视频的爱编程的大丙，博客链接：https://subingwen.cn/，有做了相应的补充！

 一、线程池的原理

线程池是一种多线程处理的形式，处理过程中将任务添加到队列，任何在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件的发生），则线程池将插入另外一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

线程池的组成主要分为 3 个部分，这三部分配合工作就可以得到一个完整的线程池：

• 任务队列，存储需要处理的任务，由工作的线程来处理这些任务

（1）通过线程池提供的API函数，将一个待处理的任务添加到任务队列，或者从任务队列中删除；

（2）已处理的任务将被删除；

（3）线程池的使用者，也就是调用线程池函数往任务队列中添加任务的线程就是生产者线程。

• 工作线程（任务队列中任务的消费者），N个

（1）线程池维护了一定数量的工作线程，它们的作用是不断的读取任务队列，从里边取出任务并处理；

（2）如果任务队列为空，工作线程将会被阻塞（使用条件变量或信号量阻塞）；

（3）如果阻塞之后有了新的任务，由生产者将阻塞解除，工作线程开始工作；

• 管理者线程（不处理任务队列中的任务），1个

（1）它的任务是周期性的对任务队列中的任务数量以及处于忙状态的工作线程个数进行检测；

（2）当任务过多的时候，可以适当的创建一些新的工作线程；

（3）当任务过少的时候，可以适当的销毁一些工作线程；

1. 任务队列

（1）类的声明

#pragma once
#include <queue>
#include <pthread.h>
 
using callback=void(*)(void* arg);
//任务结构体
template<typename T>
struct Task
{
    Task()
    {
        function=nullptr;
        arg=nullptr;
    }
    Task(callback f,void* arg)
    {
        function=f;
        this->arg=(T*)arg;
    }
    callback function;
    T* arg;
};
 
template<typename T>
//任务队列
class TaskQueue
{
public:
    TaskQueue();
    ~TaskQueue();
 
    //添加一个任务
    void addTask(Task<T> task);
    void addTask(callback f,void* arg);
    //取出一个任务
    Task<T> taskTask();
    //获取当前任务个数
    inline size_t taskNumber()
    {
        return m_taskQ.size();
    }
private:
    pthread_mutex_t m_mutex;
    std::queue<Task<T>> m_taskQ;
};

• 其中 Task 是任务类，里边有两个成员，分别是两个指针 void(*)(void*) 和 void*；
• 另外一个类 TaskQueue 是任务队列，提供了添加任务、取出任务、存储任务、获取任务个数、线程同步的功能。

（2）类定义

 #include "TaskQueue.h"
 
template<typename T>
TaskQueue<T>::TaskQueue() 
{
    pthread_mutex_init(&m_mutex,NULL);
}
 
template<typename T>
TaskQueue<T>::~TaskQueue() 
{
    pthread_mutex_destroy(&m_mutex);
}
 
template<typename T>
void TaskQueue<T>::addTask(Task<T> task) 
{
    pthread_mutex_lock(&m_mutex);
    m_taskQ.push(task);
    pthread_mutex_unlock(&m_mutex);
}
 
template<typename T>
void TaskQueue<T>::addTask(callback f,void* arg) 
{
    pthread_mutex_lock(&m_mutex);
    m_taskQ.push(Task<T>(f,arg));
    pthread_mutex_unlock(&m_mutex);
}
 
template<typename T>
Task<T> TaskQueue<T>::taskTask() 
{
    Task<T> task;
    pthread_mutex_lock(&m_mutex);
    if(!m_taskQ.empty())
    {
        task=m_taskQ.front();
        m_taskQ.pop();
    }
    pthread_mutex_unlock(&m_mutex);
    return task;
}

2、线程池

（1） 类声明

#pragma once
#include "TaskQueue.h"
#include "TaskQueue.cpp"
 
template<typename T>
class ThreadPool
{
private:
    //任务队列
    TaskQueue<T>* taskQ;
 
    pthread_t managerID;       //管理者线程ID
    pthread_t* threadIDs;      //工作线程ID
    int minNum;                //最小线程数量
    int maxNum;                //最大线程数量
    int busyNum;               //忙的线程个数
    int liveNum;               //存活的线程个数
    int exitNum;               //要销毁的线程个数
    pthread_mutex_t mutexPool; //锁整个线程池
    pthread_cond_t notEmpty;   //任务队列是否为空了
 
    bool shutdown;             //是不是要销毁线程池,销毁为1,不销毁为0
    static const int NUMBER=2;
 
public:
    //创建线程池并初始化
    ThreadPool(int min,int max);
    //销毁线程池
    ~ThreadPool();
 
    //给线程池添加任务
    void addTask(Task<T> task);
 
    //获取线程池中工作的线程个数
    int getBusyNum();
 
    //获取线程池中活着的线程个数
    int getAliveNum();
 
private:
    //工作的线程（消费者线程）任务函数
    static void* worker(void* arg);
    //管理者线程任务函数
    static void* manager(void* arg);
    //单个线程退出
    void threadExit();
};

（2）类定义

#include "ThreadPool.h"
#include <iostream>
#include <string.h>
#include <string>
#include <unistd.h>
using namespace  std;
 
template<typename T>
ThreadPool<T>::ThreadPool(int min,int max) 
{
    do
    {
        //实例化任务队列
        taskQ=new TaskQueue<T>;
        if(taskQ==nullptr)
        {
            cout<<"malloc taskQ fail...\n";
            break;
        }
        threadIDs=new pthread_t[max];
        if(threadIDs==nullptr)
        {
            cout<<"malloc threadIDs fail...\n";
            break;
        }
        memset(threadIDs,0,sizeof(pthread_t)*max);
        minNum=min;
        maxNum=max;
        busyNum=0;
        liveNum=min;  //和最小个数相等
        exitNum=0;
 
        if(pthread_mutex_init(&mutexPool,NULL)!=0||
          pthread_cond_init(&notEmpty,NULL)!=0)
        {
            cout<<"mutex or condition init fail...\n";
            break;
        }
 
        shutdown=false;
        //创建管理者线程
        //第三个参数在类内部,需要传入已经存在的地址(类实例化才有)
        //,因此换成静态成员函数或友元函数;传入this是为了可以
        //访问其它成员属性和方法,静态方法只能访问静态的属性
        pthread_create(&managerID,NULL,manager,this);
        //创建工作线程                                 
        for(int i=0;i<min;++i)                      
        {
            pthread_create(&threadIDs[i],NULL,worker,this);
        }
        return;
    }while(0);
 
    //创建失败,释放资源
    if(threadIDs) delete[] threadIDs;
}
 
template<typename T>
ThreadPool<T>::~ThreadPool() 
{
    //关闭线程池
    shutdown=true;
    //阻塞回收管理者线程池
    pthread_join(managerID,NULL);
    //唤醒阻塞的工作线程(消费者线程)
    for(int i=0;i<liveNum;++i)
    {
        pthread_cond_signal(&notEmpty);
    }
 
    //释放堆内存
    if(taskQ)
    {
        delete taskQ;
    }
    if(threadIDs)
    {
        delete []threadIDs;
    }
    pthread_mutex_destroy(&mutexPool);
    pthread_cond_destroy(&notEmpty);
}
 
template<typename T>
void ThreadPool<T>::addTask(Task<T> task) 
{
    if(shutdown)//已满
    {
        return;
    }
    //添加任务
    taskQ->addTask(task);
    pthread_cond_signal(&notEmpty);//唤醒工作线程
}
 
template<typename T>
int ThreadPool<T>::getBusyNum() 
{
    pthread_mutex_lock(&mutexPool);
    int busyNum=this->busyNum;
    pthread_mutex_unlock(&mutexPool);
    return busyNum;
}
 
template<typename T>
int ThreadPool<T>::getAliveNum() 
{
    pthread_mutex_lock(&mutexPool);
    int aliveNum=this->liveNum;
    pthread_mutex_unlock(&mutexPool);
    return aliveNum;   
}
 
template<typename T>
//工作线程
void* ThreadPool<T>::worker(void* arg) 
{
    //利用传入的this类调用该成员属性和方法
    ThreadPool* pool=static_cast<ThreadPool*>(arg);
 
    while(true)
    {
        pthread_mutex_lock(&pool->mutexPool);
        //当前任务队列是否为空
        while(pool->taskQ->taskNumber()==0&&!pool->shutdown)
        {
            //阻塞工作线程
            pthread_cond_wait(&pool->notEmpty,&pool->mutexPool);
 
            //判断是否要销毁线程,其实是管理者线程执行这段代码
            if(pool->exitNum>0)
            {
                pool->exitNum--;
                if(pool->liveNum>pool->minNum)
                {
                    pool->liveNum--;
                    pthread_mutex_unlock(&pool->mutexPool);
                    pool->threadExit();
                }
            }
        }
 
        //判断线程池是否关闭了
        if(pool->shutdown)
        {
            pthread_mutex_unlock(&pool->mutexPool);//释放锁
            pool->threadExit();//线程退出
        }
 
        //从任务队列中取出一个任务
        Task<T> task=pool->taskQ->taskTask();
 
        pool->busyNum++;
        //解锁
        pthread_mutex_unlock(&pool->mutexPool);
        cout<<"thread "<<to_string(pthread_self())<<" start working...\n";
 
        task.function(task.arg);//执行任务函数
        delete task.arg;
        task.arg=nullptr;
 
        cout<<"thread "<<to_string(pthread_self())<<" end working...\n";
 
        pthread_mutex_lock(&pool->mutexPool);
        pool->busyNum--;
        pthread_mutex_unlock(&pool->mutexPool);
    }
    return NULL;
}
 
template<typename T>
void* ThreadPool<T>::manager(void* arg) 
{
    ThreadPool* pool=static_cast<ThreadPool*>(arg);
    while(!pool->shutdown)
    {
        //每隔3s检测一次
        sleep(3);
 
        //取出线程池中任务的数量、当前线程的数量、忙的线程的数量
        pthread_mutex_lock(&pool->mutexPool);;
        int queueSize=pool->taskQ->taskNumber();
        int liveNum=pool->liveNum;
        int busyNum=pool->busyNum;
        pthread_mutex_unlock(&pool->mutexPool);
 
        //添加线程
        //任务的个数>存活的线程个数&&存活的线程数<最大线程数
        if(queueSize>liveNum&&liveNum<pool->maxNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            int counter=0;//默认最大增加2个工作线程
            for(int i=0;i<pool->maxNum&&counter<NUMBER&&pool->liveNum<pool->liveNum<
                pool->maxNum;++i)
            {
                if(pool->threadIDs[i]==0)
                {
                    pthread_create(&pool->threadIDs[i],NULL,worker,pool);
                    counter++;
                    pool->liveNum++;
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
        }
 
        //销毁线程
        //忙的线程*2<存活的线程数&&存活的线程>最小线程数
        if(busyNum*2<liveNum&&liveNum>pool->minNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            pool->exitNum=NUMBER;
            pthread_mutex_unlock(&pool->mutexPool);
            //让工作的线程自杀
            for(int i=0;i<NUMBER;++i)
            {
                pthread_cond_signal(&pool->notEmpty);//唤醒阻塞的线程
            }
        }
    }
    return NULL;
}
 
template<typename T>
void ThreadPool<T>::threadExit() 
{
    pthread_t tid=pthread_self();
    for(int i=0;i<maxNum;++i)
    {
        if(threadIDs[i]==tid)
        {
            threadIDs[i]=0;
            cout<<"threadExit() called, "<<to_string(tid)<<" exiting...\n";
            break;
        }
    }
    pthread_exit(NULL);//线程退出
}