C++线程池的原理（画图）及简单实现+例子（加深理解）

1.为什么线程池会出现，解决什么问题？

C++线程池（ThreadPool）的出现主要是为了解决以下几个问题：
1.性能：创建和销毁线程都是相对昂贵的操作，特别是在高并发场景下，频繁地创建和销毁线程会极大地降低程序的性能。通过线程池预先创建一定数量的线程并保存在内存中，可以避免频繁地创建和销毁线程，从而提高程序的性能。
2.资源管理：线程是操作系统级别的资源，如果线程数量过多，可能会导致系统资源的过度消耗，甚至可能导致系统崩溃。通过线程池，可以控制同时运行的线程数量，避免资源过度消耗。
3.任务调度：线程池可以更方便地进行任务的调度。通过线程池，可以将任务分配给不同的线程执行，实现并行处理，提高程序的执行效率。
4.简化编程：使用线程池可以简化多线程编程的复杂性。程序员只需要将任务提交给线程池，而不需要关心线程的创建、管理和销毁等细节，降低了多线程编程的难度。
因此，C++线程池的出现是为了解决在高并发场景下创建和销毁线程的开销问题，提高程序的性能和并发处理能力，简化多线程编程的复杂性

................

2.简单解释下原理

线程池初始化时，初始化线程，也可以生成一个管理线程，来管理工作线线程数量。

如果当前任务队列一直有很多任务时，说明线程繁忙，处理不过来，可以根据设置的最大工作线程数来新增线程，提高并发处理能力，提高工作效率。

如果当前任务队列一直为空，说明当前时间段，没有任务或者很少的任务要处理，可以销毁多余的空闲线程，避免资源浪费。

如下图所示：

初始化线程池后，有新任务到来后，线程池处理流程为：

将新任务投递到线程队列中->发送信号通知线程处理->空闲线程处理->处理完成检查任务队列是否还有任务->有任务则提取任务处理，没有任务就挂起为空闲线程，避免占用系统资源

如下图所示：

3. 实现

用一个Task类表示任务，成员函数如下

    void (*hander)(void* arg); // 要执行任务的函数指针
    void *arg;          //可执行任务的参数
    std::string name;   //任务名
    static int taskNum; //任务数量
// task.h
class Task
{
public:
    Task();
    Task(std::string name);
    Task(void *arg);
    void createTask(void (*hander)(void* arg), void*arg);
    ~Task();

    void (*hander)(void* arg);
    void *arg;
    //Task* next;
    std::string name;
    static int taskNum;
};

// task.cpp
int Task::taskNum = 0;

Task::Task()
{
    next = nullptr;
    this->arg = nullptr;
    taskNum++;
}

Task::Task(std::string name)
{
    this->name = name;
    taskNum++;
}

Task::Task(void *arg)
{
    next = nullptr;
    this->arg = arg;
    taskNum++;
}

void Task::createTask(void (*hander)(void *), void *arg)
{
    this->hander = hander;
    this->arg = arg;
}

Task::~Task()
{
    if(--taskNum==0) {
        qDebug()<<"所有任务执行完成, 完成时间："<<QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz");
        free(this->arg);
    }
}

自定义线程池如下：

typedef struct {   
   Task* first;  //任务队列头  
   Task** last;  //任务队列尾部
}threadPool_Queue;

threadPool_Queue 这个结构提用来表示任务队列，对指针特性用的很巧妙，但是不好理解，我就不讲这个了，我在代码中注释掉了，感兴趣的可以把注释放开，理解下。现在用stl中的queue更好理解，用到如下成员函数，由于为了简便理解线程池，我就把管理线程去掉了

    std::queue<Task*> taskQueue;  // 任务队列
    std::condition_variable cond; / /条件变量，用于唤醒线程和挂起线程
    std::mutex mutexPool;         // 线程互斥锁，保护线程安全
    unsigned long m_maxNum;       // 线程最大数量
    unsigned long m_minNum;       // 线程最小数量
    int busyNum;                  // 线程是否繁忙，用于管理线程
    int aliveNum;                 // 活跃线程数，即繁忙线程数
    std::vector<std::thread> m_threads;// 线程队列

用到两个函数：

    void taskPost(Task* task);    //投递任务到任务队列中  
    static void worker(void* arg);//工作线程函数，用来循环不断的处理任务

代码如下所示：

// threadpool.h
#include <thread>
#include <vector>
#include <condition_variable>
#include <mutex>
#include <queue>
#include "task.h"

typedef struct {
    Task* first;
    Task** last;
}threadPool_Queue;

class ThreadPool
{

public:
    ThreadPool(unsigned long maxNum);
    ~ThreadPool();
    void taskPost(Task* task);

    static void worker(void* arg);

private:
    //threadPool_Queue queue;
    std::queue<Task*> taskQueue;
    std::condition_variable cond;
    std::mutex mutexPool;
    unsigned long m_maxNum;
    unsigned long m_minNum;
    int busyNum;
    int aliveNum;
    std::vector<std::thread> m_threads;
};

// threadpool.cpp
#include "threadpool.h"
#include "task.h"
#include <QDebug>
#include <iostream>
#include <QDateTime>

ThreadPool::ThreadPool(unsigned long maxNum)
{
    m_maxNum = maxNum;
    m_minNum = 1;

    busyNum = 0;
    aliveNum = 0;
    //queue.first = nullptr;
    //queue.last = &queue.first;
    m_threads.resize(maxNum);
    for(unsigned long i=0; i<maxNum;i++) {
        m_threads[i] = std::thread(worker, this);
    }
}

ThreadPool::~ThreadPool()
{
    //唤醒阻塞的工作线程
    cond.notify_all();
    for (unsigned long i = 0; i < m_maxNum; ++i)
    {
        if (m_threads[i].joinable()) {
            m_threads[i].join();
        }
    }
}

void ThreadPool::taskPost(Task *task)
{
    std::unique_lock<std::mutex> lk(mutexPool);
    //task->next = nullptr;
    //*queue.last = task;
    //queue.last = &task->next;
    taskQueue.push(task);
    // 通知线程处理
    cond.notify_one();
    lk.unlock();
}

void ThreadPool::worker(void *arg)
{

    ThreadPool* pool = static_cast<ThreadPool*>(arg);

    while (1) {
        // unique_lock在构造时或者构造后（std::defer_lock）获取锁
        std::unique_lock<std::mutex> lk(pool->mutexPool);
        //while (!pool->queue.first) { //没有任务时，线程挂起
        while (pool->taskQueue.empty()) { //没有任务时，线程挂起
            //挂起，直到收到主线程的事件通知
            pool->cond.wait(lk);
        }
        /*Task* task = pool->queue.first;
        pool->queue.first = task->next;
        lk.unlock();
        if(pool->queue.first==nullptr )  {
            pool->queue.last=&pool->queue.first;
        }*/
        Task* task = pool->taskQueue.front();
        pool->taskQueue.pop();//从队列中移除
        // 当访问完线程池队列时，线程池解锁
        lk.unlock();
        qDebug()<<"执行任务任务开始时间:"<<QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz");

        task->hander(task->arg);
        std::cout << task->name << " finish!" <<std::endl;
        delete task;
    }
}

4. 单线程与线程池的对比结果

然后在写个测试的例子，突出线程池的并发能力

先定义一个任务函数，用来计算累加值，计算1+2+3+...+value的值，相当于一个任务

void executeTask_1(void* size) {
    int* s = static_cast<int*>(size);
    int value = *s;
    long sum=0;
    for(int i=0; i<value; i++) {
        sum+=i;
    }
    std::cout << "计算完成，sum= " <<sum << std::endl;
}

然后在main函数中，执行四次这个任务，用一般流程下（即单线程）执行四次这个任务需要多长时间，和在线程池中的执行时间进行对比，我在线程池中初始化了四个线程，用于并发处理任务

int main()
{
    long* n = new long;
    *n = 1000000000;
    // 获取当前时间
    auto start = std::chrono::system_clock::now();
    executeTask_1(n);
    executeTask_1(n);
    executeTask_1(n);
    executeTask_1(n);
    // 获取操作完成后的时间
    auto end = std::chrono::system_clock::now();
    // 计算时间差
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    // 输出时间差（以毫秒为单位）
    std::cout << "一般流程执行所有任务所需时间: " << duration.count() << "毫秒" << std::endl;


    ThreadPool pool(4);
    Task* t1 = new Task("Task1");
    t1->createTask(executeTask_1, n);
    Task* t2 = new Task("Task2");
    t2->createTask(executeTask_1, n);
    Task* t3 = new Task("Task3");
    t3->createTask(executeTask_1, n);
    Task* t4 = new Task("Task4");
    t4->createTask(executeTask_1, n);
    // 获取当前时间
    qDebug()<<"线程池执行任务开始时间:"<<QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz");
    pool.taskPost(t1);
    pool.taskPost(t2);
    pool.taskPost(t3);
    pool.taskPost(t4);

    return 0;
}

结果如下所示：

可以看出，计算四次从1-十亿累加值的任务一般流程（即单线程）需要7.816秒，平均每一次：1.954秒

而用线程池执行的任务是同时开始的（在毫秒误差内），所有任务执行完成，用了41.131-39.117=2.014秒

数据对比可以看出，使用4个线程并发处理，和一个线程处理的时间差不多，说明线程池的并发处理是没有问题的

我把线程池线程数初始化为2，也符合预判

5. 总结

可以看出，在处理多个相同任务的时候，线程池（线程数量为4时）的速度几乎是单线程的4倍，当然，线程数不是越多越好，取决于CPU的核数（最好不要大于CPU的核数，因为太多的工作线程会竞争CPU的资源，带来不必要的上下文切换，小于CPU的核数则不能够充分利用CPU）。

对于某些场景，使用线程池是很有必要的，在需要高并发的服务器中线程池几乎是必备的，如文件传输的服务器，多用户下载或者上传文件时，几乎是同步的，在高并发场景下，如果每个请求都创建一个新线程，会导致线程数量过多，同时线程的创建和销毁也需要消耗大量的资源。为了解决这些问题，可以使用线程池技术。线程池预先创建一定数量的线程，并且可以在多个请求之间复用这些线程，从而提高服务器的处理能力和资源利用率。因此，在高并发的服务器中，使用线程池技术可以有效地降低资源消耗、提高系统性能和响应速度，是非常必要和常用的技术手段之一。

虽然现在有很多封装好的线程池供我们调用。但是，其原理也是值得我们推敲的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/290035.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

ubuntu18.04安装MySQL

ubuntu18.04安装MySQL

1.安装mysql服务器端 sudo apt-get -y install mysql-server&#xff08;18.04/20.04不会提示输入密码&#xff0c;默认是没有密码&#xff09; 2.安装mysql客户端 sudo apt-get -y install mysql-client3.安装mysql模块 sudo apt-get -y install libmysqlclient-dev4.验证是…
阅读更多...
data.TensorDataset解析

data.TensorDataset解析

data.TensorDataset 是 PyTorch 中的一个类&#xff0c;用于创建一个包含多个张量的数据集。这个类的主要作用是将输入的张量组合成一个数据集&#xff0c;使得在训练过程中可以方便地进行数据加载和迭代。 具体来说&#xff0c;TensorDataset 接受一系列的张量作为输入参数&a…
阅读更多...
字符集字符编码

字符集字符编码

字符集 字符&#xff08;Character&#xff09;是各种文字和符号的总称&#xff0c;包括各国家文字、标点符号、图形符号、数字等。而字符集&#xff08;Character set&#xff09;则是多个字符的集合。 简单的说&#xff0c;字符集就规定了某个文字对应的二进制数字存放方式…
阅读更多...
springboot整合springbatch批处理

springboot整合springbatch批处理

springboot整合springbatch实现批处理 简介项目搭建步骤 简介 项目搭建 参考博客【场景实战】Spring Boot Spring Batch 实现批处理任务&#xff0c;保姆级教程 步骤 1.建表 建表sql CREATE TABLE student (id int NOT NULL AUTO_INCREMENT,name varchar(100) NOT NULL C…
阅读更多...
[C#]yolov8-onnx在winform部署手势识别模型

[C#]yolov8-onnx在winform部署手势识别模型

【官方框架地址】 https://github.com/ultralytics/ultralytics.git 【算法介绍】 YOLOv8 是一个 SOTA 模型&#xff0c;它建立在以前 YOLO 版本的成功基础上&#xff0c;并引入了新的功能和改进&#xff0c;以进一步提升性能和灵活性。具体创新包括一个新的骨干网络、一个新…
阅读更多...
牛客网面试题知识点记录-03

牛客网面试题知识点记录-03

1.题目讲解重写后子类调用父类的方法总结&#xff1a;当子类重写了父类方法A&#xff0c;父类方法直接调用被重写的父类方法后&#xff0c;调用的是子类的重写的父类方法A。 class Test {public static void main(String[] args) {System.out.println(new B().getValue());}st…
阅读更多...
Java的并发修改异常

Java的并发修改异常

作者简介&#xff1a;大家好&#xff0c;我是smart哥&#xff0c;前中兴通讯、美团架构师&#xff0c;现某互联网公司CTO 联系qq&#xff1a;184480602&#xff0c;加我进群&#xff0c;大家一起学习&#xff0c;一起进步&#xff0c;一起对抗互联网寒冬 学习必须往深处挖&…
阅读更多...
原生JS调用OpenAI GPT接口并实现ChatGPT逐字输出效果

原生JS调用OpenAI GPT接口并实现ChatGPT逐字输出效果

效果&#xff1a; 猜你感兴趣&#xff1a;springbootvue实现ChatGPT逐字输出打字效果 附源码&#xff0c;也是小弟原创&#xff0c;感谢支持&#xff01; 没废话&#xff0c;上代码&#xff1a; <!DOCTYPE html> <html lang"en"> <head><me…
阅读更多...
【Proteus仿真】【STM32单片机】超声波测距系统

【Proteus仿真】【STM32单片机】超声波测距系统

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真STM32单片机控制器&#xff0c;使用动态数码管、按键、HCSR04超声波、蜂鸣器模块等。 主要功能&#xff1a; 系统运行后&#xff0c;数码管显示超声波检测距离&#xff0c;当检测…
阅读更多...
奈奎斯特定理

奈奎斯特定理

奈奎斯特定理是通信领域中重要的理论基础之一&#xff0c;它对于数字通信系统中的信号采样和重构具有至关重要的作用。在数字信号处理和通信技术中&#xff0c;奈奎斯特定理的应用不仅具有理论意义&#xff0c;还对通信系统的设计、优化和性能提升起着重要的指导作用。本文将以…
阅读更多...
8868体育助力意甲博洛尼亚俱乐部 主帅被评为最佳

8868体育助力意甲博洛尼亚俱乐部 主帅被评为最佳

博洛尼亚俱乐部是8868体育合作球队之一&#xff0c;本赛季在意甲联赛中表现出色&#xff0c;目前以8胜7平2负的成绩排名第四&#xff0c;积31分。意大利媒体评选出的年度最佳主帅是莫塔&#xff0c;本赛季莫塔率领博洛尼亚连续战胜强敌&#xff0c;目前在意甲积分榜上排名第四&…
阅读更多...
进阶学习——Linux系统中重点‘进程’

进阶学习——Linux系统中重点‘进程’

目录 一、程序和进程的关系 1.程序 2.进程 2.1线程 2.2协程 3.进程与线程的区别 4.总结 4.1延伸 5.进程使用内存的问题 5.1内存泄漏——Memory Leak 5.2内存溢出——Memory Overflow 5.3内存不足——OOM&#xff08;out of memory&#xff09; 5.4进程使用内存出现…
阅读更多...
Algorithm-Left Edge算法

Algorithm-Left Edge算法

算法输入&#xff1a; 多个段&#xff0c;每个段由两个值表示&#xff0c;例如&#xff08;1&#xff0c;3&#xff09; 算法原理&#xff1a; 将多个段按照左边的值排序放到列表中遍历列表&#xff0c;不断选择没有重叠的段&#xff0c;直到列表遍历结束&#xff0c;将选择…
阅读更多...
fineBI web组件传参

fineBI web组件传参

1、fineBI web组件传参 1.1、 Web组件- FineBI帮助文档 FineBI帮助文档1. 概述1.1 版本FineBI 版本HTML5移动端展现功能变动6.0--V11.0.83web组件适配移动端效果优化6.0.13-web组件支持传递参数 ${过滤组件https://help.fanruan.com/finebi/doc-view-143.html 1.2、自己做的例…
阅读更多...
Java 将Excel转换为TXT文本格式

Java 将Excel转换为TXT文本格式

TXT文件是一种非常简单、通用且易于处理的文本格式。在处理大规模数据时&#xff0c;将Excel转为TXT纯文本文件可以提高处理效率。此外&#xff0c;许多编程语言和数据处理工具都有内置的函数和库来读取和处理TXT文件&#xff0c;因此将Excel文件转换为TXT还可以简化数据导入过…
阅读更多...
如何读取tif格式文件（基于PIL）

如何读取tif格式文件（基于PIL）

背景介绍 在许多机器学习的任务中&#xff0c;大多数图像类型的训练数据集会以tif的格式储存&#xff0c;在这种情况下&#xff0c;如何读取tif格式的数据就至关重要 tif格式 TIF&#xff08;Tagged Image File Format&#xff09;格式&#xff0c;也被称为TIFF&#xff0c;是…
阅读更多...
基于Vue开发的一个仿京东电商购物平台系统(附源码下载)

基于Vue开发的一个仿京东电商购物平台系统(附源码下载)

电商购物平台项目 项目完整源码下载 基于Vue开发的一个仿京东电商购物平台系统 Build Setup # csdn下载该项目源码压缩包 解压重命名为sangpinghui_project# 进入项目目录 cd sangpinghui_project# 安装依赖 npm install# 建议不要直接使用 cnpm 安装以来&#xff0c;会有各…
阅读更多...
生成式AI在自动化新时代中重塑RPA

生成式AI在自动化新时代中重塑RPA

生成式AI的兴起正在推动行业的深刻变革&#xff0c;其与RPA技术的结合&#xff0c;标志着自动化领域新时代的到来。这种创新性结合极大地提升了系统的适应性&#xff0c;同时也推动了高级自动化解决方案的发展&#xff0c;为下一代RPA的诞生奠定了坚实的基础。 核心RPA技术专注…
阅读更多...
数据结构——二叉树四种遍历的实现

数据结构——二叉树四种遍历的实现

目录 一、树的概念 1、树的定义 1&#xff09;树 2&#xff09;空树 3&#xff09;子树 2、结点的定义 1&#xff09;根结点 2&#xff09;叶子结点 3&#xff09;内部结点 3、结点间关系 1&#xff09;孩子结点 2&#xff09;父结点 3&#xff09;兄弟结点 4、树…
阅读更多...
船舶数据采集与分析在线能源监测解决方案

船舶数据采集与分析在线能源监测解决方案

一、船舶在线能源监测应用前景 船舶在线能源监测在能源效率优化、故障诊断和预测维护、节能减排和环保监管、数据分析和决策支持以及自动化智能化等方面具有广阔的应用前景。随着船舶行业对能源管理和环保要求的不断提高&#xff0c;船舶在线能源监测技术将成为船舶运营和管理中…
阅读更多...
最新文章

Copyright @ 2022~2023