基于C++11的线程池

基于cpp11完成的线程池

线程池线程数量在构造对象时可指定。

线程池中包含一个deque的任务队列。

可通过外部接口像队列中增加任务。

当有空闲线程时便会处理任务队列中的任务。

析构或结束时回收线程资源。

ThreadPool.h文件

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

using Task = std::function;

class ThreadPool
{
public:
    //构造函数，默认开启10个线程
    ThreadPool(int num=10);
    ~ThreadPool();
    //开启此线程池
    void stopPool();
    //关闭线程池
    void startPool();
    //像任务队列中增加任务
    void addTask(Task task);
    //线程执行任务的函数
    void doTask();

private:
    std::condition_variable m_conDequeNotEmpty; //任务队列非空通知
    std::deque m_deqTask;     //任务队列
    std::mutex m_mutex;     //锁
    std::vector m_vecThread;   //线程存储在vec中
    int m_ithreadNum;   //线程数量
    std::atomic m_bIsRunning{ false };    //是否正在运行
};

ThreadPool.cpp

#include "stdafx.h"
#include "ThreadPool.h"
#include 
#include 


ThreadPool::ThreadPool(int num)
    :m_ithreadNum(num)
{
}

//析构时运行状态置为false，并通知所有等待线程，状态置为false后
//dotask中就可以退出
ThreadPool::~ThreadPool()
{
    m_bIsRunning = false;
    //通知所有线程不要再等待了
    m_conDequeNotEmpty.notify_all();
    for (auto &item : m_vecThread)
    {
        //回收线程资源
        if (item.joinable())
        {
            item.join();
        }
    }
}

void ThreadPool::stopPool()
{
    //运行状态置为false
    m_bIsRunning = false;
    //逻辑和析构函数一样
    m_conDequeNotEmpty.notify_all();
    for (auto &item : m_vecThread)
    {
        //回收线程资源
        if (item.joinable())
        {
            item.join();
        }
    }
}

//开启线程池，创建一定数量的线程，并绑定dotask函数
void ThreadPool::startPool()
{
    m_bIsRunning = true;
    for (int i = 0; i < m_ithreadNum; ++i)
    {
        std::thread t(&ThreadPool::doTask, this);
        m_vecThread.push_back(move(t));
    }
}

//像任务队列中添加任务
void ThreadPool::addTask(Task task)
{
    if (m_bIsRunning)
    {
        //上锁，添加
        std::unique_lock lck(m_mutex);
        m_deqTask.push_back(task);
        //通知任务队列不空
        m_conDequeNotEmpty.notify_one();
    }
}

void ThreadPool::doTask()
{
    //循环操作
    while (1)
    {
        //要获取的任务
        Task task;
        {
            std::unique_lock lck(m_mutex);
            //正在运行状态且deque大小为空
            
            //等待任务队列不空或者状态为退出
            m_conDequeNotEmpty.wait(lck,[this]() {return !m_bIsRunning || !m_deqTask.empty(); });
            //不在运行状态且任务队列空了那就退出
            if (!m_bIsRunning&&m_deqTask.empty())
            {
                return;
            }
            //有任务就把顶端的拿出来
            task = move(m_deqTask.front());
            m_deqTask.pop_front();
        }
        //出了上边的作用域,lck就自动解锁了
        //执行任务
        task();
    }
}

main.cpp

#include 

void func() {
    printf("task is doing,id:%dn",GetCurrentThreadId());
    ::Sleep(6000);    //模拟工作时长
    printf("task finished,id:%dn", GetCurrentThreadId());
}

int main()
{
    ThreadPool p(10);
    p.startPool();
    int num = 30;
    while (num--) {
        Sleep(500);
        p.addTask(func);
    }
    return 0;
}