基于C++11/14的线程池（可添加任意类型函数任务）

b11252

已于 2022-10-29 13:13:52 修改

阅读量2k

点赞数 5

CC 4.0 BY-SA版权

分类专栏： C++ 文章标签： c++

于 2022-04-28 11:33:19 首次发布

本文链接：https://blog.youkuaiyun.com/fhakfs/article/details/124469976

C++ 专栏收录该内容

9 篇文章

订阅专栏

基于cpp14完成的线程池，具体代码也可参考本人github工程。https://github.com/qin11152

原理

线程池对象中存在一个队列（deque）去存储业务层传递来的耗时任务，供线程池中的线程获取任务并执行。

线程池中根据设定的数量构造出指定数量的线程，这些线程会获取队列中的任务并执行，当任务队列为空时，则会挂起，等待队列不为空时条件变量通知唤醒。

以下列出具体实现，并进一步解释。

ThreadPool.h文件

#pragma once
#include <deque>
#include <memory>
#include <mutex>
#include <functional>
#include <condition_variable>
#include <vector>
#include <atomic>
#include <thread>

using Task = std::function<void()>;

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<Task> m_deqTask;     //任务队列
    std::mutex m_mutex;     //锁
    std::vector<std::thread> m_vecThread;   //线程存储在vec中
    int m_ithreadNum;   //线程数量
    std::atomic<bool> m_bIsRunning{ false };    //是否正在运行
};

ThreadPool.cpp

其中较为关键的两个成员函数为startPool和doTask。

startPool函数会根据设定的线程数量开启线程，使用c++11中的线程类创建线程，线程所执行的函数则为doTask。

在doTask函数中开启了while循环，首先要获得锁，保证获取deque中的值正确。获得锁之后则不断的查看队列的状态，当队列为空时条件变量就会进入等待状态，等待至队列不为空的通知或停止运行时，结束等待。之后便从任务队列中获取一个Task（Task为要执行的任务即function<void()>）并执行。

//开启线程池，创建一定数量的线程，并绑定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::doTask()
{
    //循环操作
    while (1)
    {
        //要获取的任务
        Task task;
        {
            std::unique_lock<std::mutex> lck(m_mutex);
            //正在运行状态且deque大小为空
            /*if (m_bIsRunning && 0 == m_deqTask.size())
            {
                printf("thread id:%d,", GetCurrentThreadId());
                printf("wiat state\n");
                //没有任务的时候就等待
                m_conDequeNotEmpty.wait(lck);
            }*/
            //等待任务队列不空或者状态为退出
            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();
    }
}

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


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();
        }
    }
}

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

main.cpp

#include <windows.h>

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

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

添加任意类型任务

上述线程池包含线程池基本功能，但在其addtask时只能添加void()类型的函数，下面对其进行改进，使用模板元编程方法，使得线程池可接受任意类型的函数。

template<typename F, typename...Args>
auto addTask(F&& f, Args&&... args)
{
    std::function<decltype(f(args...))()> func = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
    auto task_ptr = std::make_shared<std::packaged_task<decltype(f(args...))()>>(func);
    std::function<void()> wrapperFunc = [=]() {
    (*task_ptr)();
    };
            
    m_deqTask.push_back(wrapperFunc);
    m_conDequeNotEmpty.notify_one();
    return task_ptr->get_future();
}

其中typename...Args为可变参数，可以接受任意数量的参数，通过bind函数将传入的函数f和对应的参数列表绑定为可执行对象，并通过packged_task封装为智能指针，最后通过匿名表达式包装为function<void()>类型，传入队列之中。如果先要获取执行结果，可以返回get_future，外部通过get获取结果，不然可以不返回值。

如果不使用packged_task再次封装一层，直接使用一下形式代码则会出现执行时对象已经释放的情况，造成崩溃。而function对象又无法封装为智能指针，故需使用packged_task。

    std::function<decltype(f(args...))()> func = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
    std::function<void()> wrapperFunc = [=]() {
        func();
    };

该类型线程池使用方法如下，给出了普通函数，类成员函数以及返回值的使用方法。

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

int add(int a, int b)
{
    Sleep(2000);
    return a + b;
}

class TestPool
{
public:
    void func1(int a, int b)
    {
        printf("task is doing,thread id:%d\n", GetCurrentThreadId());
        int tmpNum = a + b;
        ::Sleep(6000);    //模拟工作时长
        printf("task finished,thread id:%d,result:%d\n", GetCurrentThreadId(), tmpNum);
    }
};

int main()
{
    ThreadPool threadPool(10);
    threadPool.startPool();
    auto result = threadPool.addTask(add, 1, 4);//获取返回结果
    threadPool.addTask(func);//普通函数
    printf("add result:%d\n", result.get());//get会阻塞程序执行
    TestPool testPool;
    threadPool.addTask(std::bind(&TestPool::func1, &testPool, std::placeholders::_1, std::placeholders::_2), 3, 4);//成员函数
    return 0;
}