C++11 编写可复用多线程任务池 (开源OEasyPool)

转载 已于 2023-05-24 10:42:08 修改 · 581 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
原文链接：https://blog.csdn.net/csnd_ayo/article/details/72457190
收录于
C++11学习笔记

当前文章被收录于：

C++11学习笔记
11 篇文章 0 人学习

c++11

订阅专栏 查看详情
于 2021-02-19 10:37:56 首次发布
本文详细介绍了如何使用C++11实现一个线程池，包括任务基类`Task`、任务队列`TaskQueue`和线程池`ThreadPool`的实现。线程池配置、任务的添加、删除和监控等方面都进行了讲解，同时讨论了智能指针、原子类型、无序Map和锁机制等技术的应用。示例代码展示了线程池的初始化、任务调度和资源释放过程。

引言

涉及内容

  • 智能指针

  • 原子类型

  • 无序Map

  • 线程

  • 条件变量

  • 锁机制

大雄的线程池

　　原来线程池是这么来的，我也很惊讶。是大雄的愚蠢，才让我们见识到这么厉害的宝贝。

　　有人说，大雄拿到的明明是自动鱼池，我们的是线程池，压根是两个东西。
　　
　　其实，这也多亏了大雄，因为大雄最近也在学编程。

　　至于大雄学编程的故事，我们下回再讲。^_^.

　　大雄不甘寂寞写了一份线程池分享给大家　[点击免费下载]

结语

　　线程池是为了避免创建和回收，以减少不必要的资源开销，维护特定的线程资源，在需要的时候使用，不需要的时候等待需要，长时间处于闲置的线程，则主动释放。这样的运行机制，在请求频繁的系统中广为应用。更高级的用法还有多线程池的方法。

使用介绍

接下来，我将以逻辑顺序的方式讲解线程池的制作过程。（逻辑方式便于理解）若没有源码的朋友，可以翻到上面，下载源码后，跟着文章一起阅读。

类的功能

  • Task （任务基类）

    该类主要实现一个任务类
    virtual int doWork() = 0;

  • TaskQueue （任务队列）

    该类主要针对任务的存储、删除、撤回等状态做管理

  • ThreadPool （线程池）

    整个线程池的核心业务处理类

Main函数

我们来讲解第一个示例Demo test_base

  • ThreadPoolDemo.cpp

  • #include <time.h>

#include <iostream>

#include <memory>

#include "ThreadPool.h"

#include "../test/TaskTest.h"

using namespace std;

int main(void)
{
    OEThreadPool::ThreadPoolConfig threadPoolConfig;
    threadPoolConfig.nMaxThreadsNum = 100;
    threadPoolConfig.nMinThreadsNum = 5;
    threadPoolConfig.dbTaskAddThreadRate = 3;
    threadPoolConfig.dbTaskSubThreadRate = 0.5;
    clock_t start = clock();
    {

        std::shared_ptr<OEThreadPool> threadPool(new OEThreadPool);
        threadPool->init(threadPoolConfig);

        int nID = 0;
        while (true)
        {
            std::shared_ptr<OETaskTest> request = std::shared_ptr<OETaskTest>(new OETaskTest());

            threadPool->addTask(request);
            if (request->getID() == 101000) {
                break;
            }
        }

        threadPool->release();
    }
    clock_t finish = clock();
    std::cout << "duration:" << finish - start << "ms"<< std::endl;
    getchar();
    return 0;
}

    这里主要做了一些线程池的运行测试工作，我们从这个Demo,可以了解到对这个线程池基本的操作。

    1. 线程池的初始化
    2. 创建任务类
    3. 添加任务到线程池当中
    4. 线程池异步处理
    5. 清理线程池资源

配置

关于线程池的配置，我们也留出了接口。
通过 OEThreadPool 类中的 tagThreadPoolConfig 结构体与 init 函数，进行线程池的资源配置。

代码中已经有了比较详尽的注释，但是在这里我还是想贴出来再强调一遍，虽然他很简单，但是看起来非常重要。

/// 线程池配置参数
typedef struct tagThreadPoolConfig {
    int nMaxThreadsNum;         /// 最大线程数量
    int nMinThreadsNum;         /// 最小线程数量
    double dbTaskAddThreadRate;   /// 增 最大线程任务比 (任务数量与线程数量，什么比例的时候才加)
    double dbTaskSubThreadRate;   /// 减 最小线程任务比 (任务数量与线程数量，什么比例的时候才减)
} ThreadPoolConfig;

线程池在没有合理的init之前，是不会开展工作的。

扩展

关于任务线程池的扩展，我们已经提供了很好的解决方案。
例如继承 Task 类，来完成线程任务的扩展。

例如案例中 TaskTest.h 中使用的那样，将主要的业务逻辑放在 doWork 中即可。

讲解

从关联的角度讲解各个类的实现

OETask –> OETaskQueue –> OEThreadPool

结构图

1

主要从任务基类开始做延伸扩展。

2

点击查看大图

任务抽象基类

文件名：Task.h

#ifndef __OETASK_H__
#define __OETASK_H__

#include <atomic>

// 任务基类
class OETask
{

protected:

    // 任务的唯一标识
    int id_;

private:
    static int nRequestID_;
    // 任务取消状态
    std::atomic<bool>  bIsCancelRequired_;

public:
    OETask() :id_(nRequestID_++), bIsCancelRequired_(false) {};
    virtual ~OETask() {};

public:
    // 任务类虚接口，继承这个类的必须要实现这个接口
    virtual int doWork() = 0;

    // 任务已取消回调
    virtual int onCanceled(){ return 1; }
    // 任务已完成
    virtual int onCompleted(int){ return 1; }

    // 获取任务ID
    int getID(){ return id_; }
    // 设置ID
    void setID(int nID){ id_ = nID; }
    // 获取任务取消状态
    bool isCancelRequired(){ return bIsCancelRequired_; }
    // 设置任务取消状态
    void setCancelRequired(){ bIsCancelRequired_ = true; }

};

__declspec(selectany) int OETask::nRequestID_ = 100000;
#endif // __OETASK_H__

这是一个抽象的任务基类， 他的声明是如此简单，是不是觉得有些鸡肋？ 其实不是的，你可以根据这个基类，做一些自己的扩展。

例如，我做了以下扩展，来帮助我查询任务的执行状态，有效的异步监控任务。

class SKTask :
    public OETask
{
public:

    SKTask() :OETask() {
        CommonData::setTaskStatus(id_, MODULE_TASK_CREATE);
    }

    virtual ~SKTask() {
    }

    virtual int doWork() {
        CommonData::setTaskStatus(id_, MODULE_TASK_PROCESS);
        return 0;
    }

    virtual int onCanceled(void) {
        CommonData::setTaskStatus(id_, MODULE_TASK_CANCEL);
        return 0;
    }
    // 任务已完成
    virtual int onCompleted(int code) {
        CommonData::setTaskStatus(id_, code);
        return 0;
    }
};

这里有必要着重讲一下的是 onCompleted 函数，这个函数的参数是doWork的返回值。

当然 你也可以做很多你自己的扩展，例如添加几个成员函数，再或者使用一下C++11 的 bind 函数，是的这个函数非常棒，至少我很喜欢。如果你觉得这个函数很面生，我想你有必要好好的了解下他。

任务队列

文件名：taskqueue.h

#ifndef __OETASKQUEUE_H__
#define __OETASKQUEUE_H__

#include <deque>
#include <mutex>
#include <condition_variable>
#include <unordered_map>
#include <memory>

#include "Task.h"

/// 任务队列类
class OETaskQueue
{
public:
    OETaskQueue();
    ~OETaskQueue();

private:
    /// 就绪任务队列
    std::deque<std::shared_ptr<OETask> > queue_;
    /// 运行任务map
    std::unordered_map<int, std::shared_ptr<OETask>> mapDoingTask_;
    /// 互斥量
    std::mutex mutex_;
    /// 条件变量
    std::condition_variable conditPut_;

public:
    /**
    * @brief ：向队列的末尾插入任务
    * @param ：task 任务类
    */
    void put_back(std::shared_ptr<OETask> task);
    /**
    * @brief ：向队列的头部插入任务
    * @param ：task 任务类
    */
    void put_front(std::shared_ptr<OETask> task);
    /**
    * @brief ：获取队首（并将任务加到运行任务列表中）
    * @return：任务类
    */
    std::shared_ptr<OETask> get(void);
    /**
    * @brief ：获取整个双向链表的大小
    * @return：大小
    */
    size_t size(void);

    /**
    * @brief ：释放队列
    */
    void release(void);
    /**
    * @brief ：删除任务（从就绪队列删除，如果就绪队列没有，则看执行队列有没有，有的话置下取消状态位）
    * @param ：nID 任务的编号
    * @return：成功返回0 失败返回非0
    */
    int deleteTask(int nID);
    /**
    * @brief ：删除所有任务
    * @return：成功返回0 失败返回非0
    */
    int deleteAllTasks(void);
    /**
    * @brief ：任务完成回调（从运行列表中删除指定任务）
    * @param ：nID 任务的编号
    * @return：成功返回0 失败返回非0
    */
    int onTaskFinished(int nID);
    /**
    * @brief ：判断任务是否执行完毕
    * @param ：nID 任务的编号
    * @return：任务类
    */
    std::shared_ptr<OETask> isTaskProcessed(int nId);

    /**
    * @brief ：等待有任务到达（带超时：超时自动唤醒）
    * @param ：millsec 超时时间（毫秒）
    * @return：成功返回true 失败返回false
    */
    bool wait(std::chrono::milliseconds millsec);

};

#endif // __OETASKQUEUE_H__

这个队列针对任务的存储、删除、撤回等状态做了一系列的管理。使之有序的被执行（我反正是按顺序派发的任务，至于异步执行而导致的时间片的占用效率问题，我可管不了）

  • 智能锁

    这里对异步任务的提取工作，一定要注意，所以我使用了 mutex 做了一些线程安全方面的保护，对于程序而言， mutex 还是显得格格不入，我利用 std::unique_lock<std::mutex> 让这个 mutex 显得有些生机。

    如果你经常使用多线程编程，而且线程管理范围达几十个，我想你会喜欢 C++11 的，更准确的说，你会喜欢 C++11 的智能锁。

线程池

文件名：threadpool.h

#ifndef __OETHREADPOOL_H__
#define __OETHREADPOOL_H__

#include "Task.h"
#include "TaskQueue.h"

/// 任务管理类
class OEThreadPool
{
public:
    /// 线程池配置参数
    typedef struct tagThreadPoolConfig {
        int nMaxThreadsNum;         /// 最大线程数量
        int nMinThreadsNum;         /// 最小线程数量
        double dbTaskAddThreadRate;   /// 增 最大线程任务比 (任务数量与线程数量，什么比例的时候才加)
        double dbTaskSubThreadRate;   /// 减 最小线程任务比 (任务数量与线程数量，什么比例的时候才减)
    } ThreadPoolConfig;

private:
    /// 任务队列
    OETaskQueue taskQueue_;

    /// 线程池配置（如果最小线程数量为1，则表示需要一个常驻的处理线程）
    ThreadPoolConfig threadPoolConfig_;
    /// 线程池是否被要求结束
    std::atomic<bool> atcWorking_;
    /// 当前线程个数
    std::atomic<int>  atcCurTotalThrNum_;
    /// 互斥量
    std::mutex mutex_;

public:
    OEThreadPool(void);
    ~OEThreadPool(void);

    /**
    * @brief ：线程池资源配置初始化
    * @param ：config 初始化的配置信息
    * @return：0 执行成功  非0 执行失败
    */
    int init(const ThreadPoolConfig& config);
    /**
    * @brief ：释放资源（释放线程池、释放任务队列）
    * @return：true 执行成功  false 执行失败
    */
    bool release(void);

    /**
    * @brief ：添加任务
    * @param ：taskptr 任务类
    * @param ：priority 是否有限处理 true：优先处理
    * @return：0 执行成功  非0 执行失败
    */
    int addTask(std::shared_ptr<OETask> taskptr, bool priority = false);

    /**
    * @brief ：删除任务（从就绪队列删除，如果就绪队列没有，则看执行队列有没有，有的话置下取消状态位）
    * @param ：nID 任务编号
    * @return：0 执行成功  非0 执行失败
    */
    int deleteTask(int nID);

    /**
    * @brief ：删除所有任务
    * @return：0 执行成功  非0 执行失败
    */
    inline int deleteAllTasks(void);
    /**
    * @brief ：判断任务是否执行完毕
    * @param ：nID 任务编号
    * @return：执行完毕，执行完返回null，否则返回任务指针
    */
    inline std::shared_ptr<OETask> isTaskProcessed(int nId);

private:
    /**
    * @brief ：获取当前线程任务比
    * @return：线程任务比
    */
    double getThreadTaskRate(void);
    /**
    * @brief ：当前线程是否需要结束
    * @return：true:可以结束 false:不可以结束
    * @note  ：已考虑到最小线程数量
    */
    bool shouldEnd(void);
    /**
    * @brief ：添加指定数量的处理线程 
    * @param ：nThreadsNum 添加的线程数量
    * @return：0 执行成功  非0 执行失败
    */
    int addProThreads(int nThreadsNum);
    /**
    * @brief ：释放线程池
    * @return：true 执行成功  false 执行失败
    */
    bool releaseThreadPool(void);
    /**
    * @brief ：任务处理线程函数
    */
    void taskProcThread(void);

};

extern OEThreadPool SystemThreadPool;

#endif // __OETHREADPOOL_H__

总结

这里的注释都是遵循 doxygen 的文档系统的注释规则，可以使用 doxygen 一键生成，可供查阅的文档。

  • 我们的收获

    1. 学习并制作了一个可复用的线程池
    2. 初步运用C++11的线程锁、条件变量、无序Map、智能指针等
标签
#多线程 #线程池
C++11 ThreadPool:一个易于使用的C ++ 11线程池。-开源
05-15
一个易于使用的C ++ 11线程池。 使用ThreadPool类对自由函数进行排队，并使用std :: for_each（）和std :: transform（）的并行版本。 可配置为仅用于标头或与库一起使用。 有许多用法示例。
C++任务队列与多线程
12-22
摘要： 　　很多场合之所以使用C++，一方面是由于C++编译后的native code的高效性能，另一方面是由于C++的并发能力。并行方式有多进程 和多线程之分，本章暂且只讨论多线程，多进程方面的知识会在其他章节具体讨论。多线程是开发C++服务器程序非常重要的基础，如何根据需求具体的设计、分配线程以及线程间的通信，也是服务器程序非常重要的部分，除了能够带来程序的性能提高外，若设计失误，则可能导致程序复杂而又混乱，变成bug滋生的温床。所以设计、开发的线程组件以供重用，无论如何都是值得的。 　　线程相关的api并不复杂，然而无论是linux还是windows系统，都是c风格的接口，我们只
【C++】开源：ThreadPoll线程池实现与使用
DevFrank的博客
07-04 1967
线程池实现与使用
从卡顿到丝滑：如何用AI视频插帧技术拯救你的老旧视频
最新发布
gitblog_00088的博客
05-16 530
你是否曾经为那些珍贵的家庭录像感到遗憾？那些充满回忆的视频因为年代久远而显得卡顿、不流畅，每次观看都让人心生惋惜。或者，你在制作视频内容时，发现拍摄的素材帧率不足，无法达到理想的流畅效果？这些问题其实有一个共同的解决方案——AI视频插帧技术。 想象一下，你手中的30帧视频，经过AI智能处理后，可以变成60帧甚至120帧的流畅画面。这不仅仅是简单的帧率提升，而是通过人工智能算法"想象"出原本不存在
C++11 14 17 20 多线程从原理到线程池实战
02-17
学习计划 每天学习一小时以上 跟着视频动手编写代码 调试代码并对比课程多提供的源码 课程目标 理解多线程原理并学会c++11 的多线程编程 理解线程池技术原理并能使用c++实现 理解c++11 14 17 20 多线程编程相关特性 常见问题 课程使用的开发工具？ 课程使用的开发工具是vs2019 课程代码是否是跨平台？ 课程代码都是基于c++自生特性，没有用到第三方库，都是跨平台 旧版本的开发工具是否可以？ 课程中的大部分代码是c++11 ，绝大部分开发工具都支持，其中c++14 17要比较新的工具支持，c++20需要vs2019 课程是否提供源码？ 课程提供源码，方便同学学习过程的出现问题，进行对照调试错误。   
C++开源线程池WThreadPool
a2886015的博客
01-28 1653
gitee地址：WThreadPool: 基于C++语言编写的线程池 介绍 基于C++语言编写的线程池，采用了无锁队列，性能更强，有管理线程，在任务繁忙时会增加线程，在任务少时会减少线程以节省资源.该工程是跨平台的 软件架构 软件架构说明 安装教程 直接使用源码中LockQueue.hpp、WThreadPool.h、WThreadPool.cpp文件集成到自己的工程即可 使用说明 1、void setMaxThreadNum(int maxNum)，设置最大线程数 2、bool wait
使用 C++11 编写可复用多线程任务池
WindSun's Blog
02-03 550
类的功能 Task （任务基类） 该类主要实现一个任务类 virtual int doWork() = 0; TaskQueue （任务队列） 该类主要针对任务的存储、删除、撤回等状态做管理 ThreadPool （线程池） 整个线程池的核心业务处理类 代码 Task.h //任务的基类 #pragma once #include <time.h> #includ...
Qter大牛
子建莫敌
05-28 272
1.OE 大牛（大牛的博客） 贡献值： ①开源项目1： C++11 编写可复用多线程任务池 (开源OEasyPool)→文章地址 ②开源项目2：Qt 实现 QQ 截图工具(开源OEasyScreenshot)→文章地址 2.前行之路还需前行 (http://blog.csdn.net/goforwardtostep) 3.乌托邦 (http://blog.csdn.net/taiyang1987912) 贡献值： ①仿QQ控制面板→文章地址 4.一去丶二三里 (http://blog.csdn.net
C++ 11线程池
灰太狼的小秘密
01-16 8044
一、基本概念 1.1 为什么要用线程池 创建/销毁线程伴随着系统开销，过于频繁的创建和销毁线程会影响程序的处理效率： 如创建线程消耗时间为T1，执行任务消耗时间为T2,销毁线程消耗时间为T3，若T1+T3 > T2 ,则开启一个线程执行该任务不划算。 1.2 线程池的基本思想 因为程序边运行边创建线程是比较耗时的，所以我们通过池化的思想：在程序开始运行前创建多个线程，这样，程序在运行时，只需要从线程池中拿来用就可以了．大大提高了程序运行效率。 参考文献： https://b...
C++开源库ThreadPool源码解析
HnIyM的博客
06-07 1450
ThreadPool开源库仅用100行代码，运用许多C11特性实现多线程。本文将梳理自己阅读过程中的理解逐行进行解释，并且给出了所有可能疑问的对应答案。
java de 线程池
tayloramanda的博客
09-16 890
线程池： java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池 作用：解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。 使用情况： 假设一个服务器完成一项任务所需时间为： T1 创建线程时间， T2 在线程中执行任务的时间， T3 销毁线程时间。 如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。 组成部分： ...
C++：Github开源7.8Kstar的线程池介绍
Bobowen的博客
08-27 2640
不仅帮助我理解了C++线程池的内部机制，还让我掌握了多线程编程中的一些重要技巧，如任务调度、线程同步和资源管理。在未来的编程实践中，我可以将这些知识应用到更复杂的多线程项目中，提高程序的性能和稳定性。通过学习这个线程池的实现，我深刻体会到，良好的代码设计对于解决复杂问题、提升软件质量至关重要。
c++ 线程池/Github 开源项目源码分析（progschj/ThreadPool）
为啥不吃肉捏 的博客
03-20 3645
维基百科上对线程池的简要介绍：线程池（thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。ThreadPool 项目地址是一个简易的基于 c++11 标准的线程池实现，采用了。
C++ 11 实现简单线程池
qq_40788199的博客
08-21 1185
C++11使用新特性，实现最简单都线程池，详细注释
开源软件:ThreadPool C++ 线程池
碧海潮生
12-24 1763
开源软件:ThreadPool C++ 线程池 本文采用知识共享署名 4.0 国际许可协议进行许可，转载时请注明原文链接，图片在使用时请保留全部内容，可适当缩放并在引用处附上图片所在的文章链接。 源码及编译使用 源码地址：ThreadPool 源码及编译cmake 文件 ： ThreadPool 编译 mkdir build cd build cmake .. make 运行： ./example 源码分析 std::future future std::future类模板定义头文件,其函数声明如
C++11实现线程池
qq_42913081的博客
01-27 1120
C++11实现线程池
C++11线程池的简单实现
热爱生活，忠于自己
04-28 4607
c++11中添加了线程库，从此标准库有了支持并发的方案。c++11标准中的线程使用极其简单，但是c++对于多线程的支持还是比较低级，高级一点的用法都需要自己实现。 线程池原理 任务量小时，可以一个任务对应一个线程，线程资源的创建与销毁的时间消耗、上下文切换资源占用都可以忽略。但是在高并发、高吞吐、低延迟的场景下，就必须降低线程资源管理的时间消耗，就需要使用线程池了。 本文通过c++11的新特性实现一个线程池，通过管理一个任务队列、线程队列，将主线程中用户提交任务到一任务队列中，空闲的线程将从任务队列中获取任
C++实现一个线程池
sinat_31608641的博客
09-17 4563
多线程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值