Linux/C++——线程池

已于 2024-05-18 16:41:39 修改
阅读量467 收藏 15
点赞数 5
分类专栏： Linux笔记 C嘎嘎 文章标签： linux c++ 运维
于 2024-05-08 11:18:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70289867/article/details/138534286
版权

文章目录

什么是线程池

线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。
在这里插入图片描述

为什么要引入线程池

  1. 在单线程的场景中，如在服务端的服务中，要对多个客户端进行服务，单个线程会阻塞住，使效率大大降低，这时候就要多个线程，
  2. 然而在使用多个线程的时候，来一个任务，就要创建一个线程去服务，当客户端退出又需要销毁线程，而频繁的创建线程销毁线程效率很低，另一方面，
  3. 如果一次有很多个线程，计算机当中的线程越多，CPU的压力就越大，因为CPU要不断在这些线程之间来回切换，此时CPU在调度线程的时候，线程和线程之间切换的成本就会变得很高。此外，一旦线程太多，每一个线程再次被调度的周期就变长了，而线程是为客户端提供服务的，线程被调度的周期变长，客户端也迟迟得不到应答。
  • 所以这里可以引入线程池，用固定数量的线程来处理任务，而这些任务由一个任务队列来管理，当有新的任务到来的时候，就可以将任务Push到线程池当中，如果线程池当中没有任务那么当前线程就会进入休眠状态。

线程池的应用场景

  1. 12306网上购票系统等
  2. 云盘文件上传和下载
  3. 网购

线程池的代码实现

  • 线程池中的多个线程负责从任务队列当中拿任务，并将拿到的任务进行处理。
  • 线程池对外提供一个pushtask接口，用于让外部线程能够将任务push到任务队列当中。
  • 任务类中能够在接收任务后对任务进行处理
  • 任务队列可能会被多个线程同时访问，所以在对任务队列操作引入互斥锁

任务类的实现

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>

class Task
{
public:
    Task()
    {
    }
    Task(int x, int y, char op) : _x(x), _y(y), _op(op), _result(0), _exitCode(0)
    {
    }
    std::string formatArg()
    {
        return std::to_string(_x) + _op + std::to_string(_y) + "= ";
    }
    std::string formatRes()
    {
        return std::to_string(_result) + "(" + std::to_string(_exitCode) + ")";
    }
    void run(){
        switch (_op)
        {
        case '+':
            _result = _x + _y;
            break;
        case '-':
            _result = _x - _y;
            break;
        case '*':
            _result = _x * _y;
            break;
        case '/':
        {
            if (_y == 0)
                _exitCode = -1;
            else
                _result = _x / _y;
        }
        break;
        case '%':
        {
            if (_y == 0)
                _exitCode = -2;
            else
                _result = _x % _y;
        }
        break;
        default:
            break;
        }

        usleep(100000);
        std::cout<<formatArg()<<formatRes()<<std::endl;
    }
    ~Task()
    {
    }

private:
    int _x;
    int _y;
    char _op;

    int _result;
    int _exitCode;
};

线程池的实现

#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <unistd.h>
#include <pthread.h>
#include "Task.hpp"

const static int N = 5;

template <class T>
class ThreadPool
{
public:
    ThreadPool(int num = N) : _num(num), _threads(num)
    {
        pthread_mutex_init(&_lock, nullptr);
        pthread_cond_init(&_cond, nullptr);
    }
    void lockQueue()
    {
        pthread_mutex_lock(&_lock);
    }
    void unlockQueue()
    {
        pthread_mutex_unlock(&_lock);
    }
    void threadWait()
    {
        pthread_cond_wait(&_cond, &_lock);
    }
    void threadWakeup()
    {
        pthread_cond_signal(&_cond);
    }
    bool isEmpty()
    {
        return _tasks.empty();
    }
    T popTask()
    {
        T t = _tasks.front();
        _tasks.pop();
        return t;
    }
    static void *threadRoutine(void *args)
    {
        pthread_detach(pthread_self());
        ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
        while (true)
        {
            // 1. 检测有没有任务
            // 2. 有：处理
            // 3. 无：等待
            // 细节：必定加锁
            tp->lockQueue();
            while (tp->isEmpty())
            {
                tp->threadWait();
            }
            T t = tp->popTask(); // 从公共区域拿到私有区域
            tp->unlockQueue();
            
            t.run(); // 处理任务，应不应该在临界区中处理？1,0
        }
    }
    void init()
    {
        // TODO
    }
    void start()
    {
        for (int i = 0; i < _num; i++)
        {
            pthread_create(&_threads[i], nullptr, threadRoutine, this); // ?
        }
    }
    void pushTask(const T &t)
    {
        lockQueue();
        _tasks.push(t);
        threadWakeup();
        unlockQueue();
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&_lock);
        pthread_cond_destroy(&_cond);
    }

private:
    std::vector<pthread_t> _threads;
    int _num;

    std::queue<T> _tasks; // 使用stl的自动扩容的特性

    pthread_mutex_t _lock;
    pthread_cond_t _cond;
};

测试代码

#include"ThreadPool.hpp"
#include<memory>
int main(){
   std::unique_ptr<ThreadPool<Task>> tp(new ThreadPool<Task>());
   tp->init();
   tp->start();
   const char* op = "+-*/%";
   
   for( ;;){
	    sleep(1);
		int x = rand() % 100;
		int y = rand() % 100;
		int index = rand() % 5;
		Task task(x, y, op[index]);
		tp->pushTask(task);
   }
}

在这里插入图片描述

拓展操作

  1. 封装一个线程类
  2. 封装一个互斥锁类，在构造的时候加锁，析构的时候解锁
  3. 用单例模式来操作线程池

拓展后的代码

线程类
#pragma once

#include <iostream>
#include <string>
#include <cstdlib>
#include <pthread.h>

class Thread
{
public:
    typedef enum
    {
        NEW = 0,
        RUNNING,
        EXITED
    } ThreadStatus;
    typedef void (*func_t)(void *);

public:
    Thread(int num, func_t func, void *args) : _tid(0), _status(NEW), _func(func), _args(args)
    {
        char name[128];
        snprintf(name, sizeof(name), "thread-%d", num);
        _name = name;
    }
    int status() { return _status; }
    std::string threadname() { return _name; }
    pthread_t threadid()
    {
        if (_status == RUNNING)
            return _tid;
        else
        {
            return 0;
        }
    }
    // 是不是类的成员函数，而类的成员函数，具有默认参数this,需要static
    // 但是会有新的问题：static成员函数，无法直接访问类属性和其他成员函数
    static void *runHelper(void *args)
    {
        Thread *ts = (Thread*)args; // 就拿到了当前对象
        // _func(_args);
        (*ts)();
        return nullptr;
    }
    void operator ()() //仿函数
    {
        if(_func != nullptr) _func(_args);
    }
    void run()
    {
        int n = pthread_create(&_tid, nullptr, runHelper, this);
        if(n != 0) exit(1);
        _status = RUNNING;
    }
    void join()
    {
        int n = pthread_join(_tid, nullptr);
        if( n != 0)
        {
            std::cerr << "main thread join thread " << _name << " error" << std::endl;
            return;
        }
        _status = EXITED;
    }
    ~Thread()
    {
    }

private:
    pthread_t _tid;
    std::string _name;
    func_t _func; // 线程未来要执行的回调
    void *_args;
    ThreadStatus _status;
};
互斥锁类
#pragma once

#include <iostream>
#include <pthread.h>

class Mutex // 自己不维护锁，有外部传入
{
public:
    Mutex(pthread_mutex_t *mutex):_pmutex(mutex)
    {}
    void lock()
    {
        pthread_mutex_lock(_pmutex);
    }
    void unlock()
    {
        pthread_mutex_unlock(_pmutex);
    }
    ~Mutex()
    {}
private:
    pthread_mutex_t *_pmutex;
};

class LockGuard // 自己不维护锁，有外部传入
{
public:
    LockGuard(pthread_mutex_t *mutex):_mutex(mutex)
    {
        _mutex.lock();
    }
    ~LockGuard()
    {
        _mutex.unlock();
    }
private:
    Mutex _mutex;
};
任务类
#pragma once
#include <iostream>
#include <string>
#include <unistd.h>

class Task
{
public:
    Task()
    {
    }
    Task(int x, int y, char op) : _x(x), _y(y), _op(op), _result(0), _exitCode(0)
    {
    }
    void operator()()
    {
        switch (_op)
        {
        case '+':
            _result = _x + _y;
            break;
        case '-':
            _result = _x - _y;
            break;
        case '*':
            _result = _x * _y;
            break;
        case '/':
        {
            if (_y == 0)
                _exitCode = -1;
            else
                _result = _x / _y;
        }
        break;
        case '%':
        {
            if (_y == 0)
                _exitCode = -2;
            else
                _result = _x % _y;
        }
        break;
        default:
            break;
        }

        usleep(100000);
    }
    std::string formatArg()
    {
        return std::to_string(_x) + _op + std::to_string(_y) + "= ?";
    }
    std::string formatRes()
    {
        return std::to_string(_result) + "(" + std::to_string(_exitCode) + ")";
    }
    ~Task()
    {
    }

private:
    int _x;
    int _y;
    char _op;

    int _result;
    int _exitCode;
};
线程池类
#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <unistd.h>
#include "Thread.hpp"
#include "Task.hpp"
#include "lockGuard.hpp"

const static int N = 5;

template <class T>
class ThreadPool
{
private:
    ThreadPool(int num = N) : _num(num)
    {
        pthread_mutex_init(&_lock, nullptr);
        pthread_cond_init(&_cond, nullptr);
    }
    ThreadPool(const ThreadPool<T> &tp) = delete;
    void operator=(const ThreadPool<T> &tp) = delete;

public:
    static ThreadPool<T> *getinstance()
    {
        if(nullptr == instance) // 为什么要这样？提高效率，减少加锁的次数！
        {
            LockGuard lockguard(&instance_lock);
            if (nullptr == instance)
            {
                instance = new ThreadPool<T>();
                instance->init();
                instance->start();
            }
        }

        return instance;
    }

    pthread_mutex_t *getlock()
    {
        return &_lock;
    }
    void threadWait()
    {
        pthread_cond_wait(&_cond, &_lock);
    }
    void threadWakeup()
    {
        pthread_cond_signal(&_cond);
    }
    bool isEmpty()
    {
        return _tasks.empty();
    }
    T popTask()
    {
        T t = _tasks.front();
        _tasks.pop();
        return t;
    }
    static void threadRoutine(void *args)
    {
        // pthread_detach(pthread_self());
        ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
        while (true)
        {
            // 1. 检测有没有任务
            // 2. 有：处理
            // 3. 无：等待
            // 细节：必定加锁
            T t;
            {
                LockGuard lockguard(tp->getlock());
                while (tp->isEmpty())
                {
                    tp->threadWait();
                }
                t = tp->popTask(); // 从公共区域拿到私有区域
            }
            // for test
            t();
            std::cout << "thread handler done, result: " << t.formatRes() << std::endl;
            // t.run(); // 处理任务，应不应该在临界区中处理？1,0
        }
    }
    void init()
    {
        for (int i = 0; i < _num; i++)
        {
            _threads.push_back(Thread(i, threadRoutine, this));
        }
    }
    void start()
    {
        for (auto &t : _threads)
        {
            t.run();
        }
    }
    void check()
    {
        for (auto &t : _threads)
        {
            std::cout << t.threadname() << " running..." << std::endl;
        }
    }
    void pushTask(const T &t)
    {
        LockGuard lockgrard(&_lock);
        _tasks.push(t);
        threadWakeup();
    }
    ~ThreadPool()
    {
        for (auto &t : _threads)
        {
            t.join();
        }
        pthread_mutex_destroy(&_lock);
        pthread_cond_destroy(&_cond);
    }

private:
    std::vector<Thread> _threads;
    int _num;

    std::queue<T> _tasks; // 使用stl的自动扩容的特性

    pthread_mutex_t _lock;
    pthread_cond_t _cond;

    static ThreadPool<T> *instance;
    static pthread_mutex_t instance_lock;
};

template <class T>
ThreadPool<T> *ThreadPool<T>::instance = nullptr;

template <class T>
pthread_mutex_t ThreadPool<T>::instance_lock = PTHREAD_MUTEX_INITIALIZER;
测试代码
#include "ThreadPoolEnd.hpp"
#include "Task.hpp"
#include <memory>


int main()
{
    printf("0X%x\n", ThreadPool<Task>::getinstance());//打印单例的地址
    printf("0X%x\n", ThreadPool<Task>::getinstance());
    printf("0X%x\n", ThreadPool<Task>::getinstance());
    printf("0X%x\n", ThreadPool<Task>::getinstance());
    printf("0X%x\n", ThreadPool<Task>::getinstance());
    printf("0X%x\n", ThreadPool<Task>::getinstance());
	const char* op = "+-*/%";
    while (true)
    {
		sleep(1);
        int x = rand() % 100;
		int y = rand() % 100;
		int index = rand() % 5;

        Task t(x, y, op[index]);
        ThreadPool<Task>::getinstance()->pushTask(t); //单例对象也有可能在多线程场景中使用！
    }
}

在这里插入图片描述

酷帅且洋仔
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux/C++多线程编程学习笔记——线程同步、锁
mwz18959217316的博客
09-20 688
linux/C++线程同步机制，锁
基于VS2019 C++的跨平台（Linux）开发的项目——360 度智能行车辅助系统
05-29
该项目由客户端、服务器构成，采用大并发通信框架思想和自定义协议，基于 TCP/IP 通讯协议封装了包含通信组件、动态数组以及线程池等技术的通信框架。以及基于 OpenCV 的图像处理功能。 功能模块：红绿灯检测、车辆...
linux下 c++实现 线程池——同步异步
weixin_43892561的博客
11-04 668
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、线程池的结构二、代码示例前置数据结构2.读入数据总结 前言 我的技术栈都是在windows积累，然而c++后端开发主要是在Linux平台，这是对我的技术栈的一个迁移。 一、线程池的结构 1. 一条线程安全的任务队列，负责为线程分配任务。 2. 一个线程管理类 handler，负责连接线程池与任务队列； 3. job struct 4. job_list记录 本质上通过一条任务队列的入队出队，为线程池中的空闲线程分配任
基于Linux的C++轻量级web服务器/webserver/httpserver——线程池
garbage_man的博客
03-14 4405
1. 背景 什么是线程池？ 线程池技术是池化技术的一种。除了线程池，还是内存池、连接池等其他池化技术。打个比方来说，线程池是将若干个随时可以执行任务的线程放在“池子”这种容器中，当我们要使用线程的时候，从线程池中取出即可；使用完成后再将线程归还给线程池，以便下次或者其他用户使用。 本项目为什么需要线程池？ 使用线程池技术的最大好处**是服务器可以避免因重复的建立和销毁线程带来的开销，**从而提高服务器对客户端的响应速度。 此外，一个线程从诞生到结束，在系统中存在的时间可以分成三个阶段：创建耗时t1, 工作时
Linux——线程池
m0_64607843的博客
03-16 530
线程池的简单实现
Linux网络编程——线程池模型
weixin_44832458的博客
05-16 146
Linux网络编程——线程池模型 文章目录Linux网络编程——线程池模型前言一、线程池主要函数说明二、代码实现 前言 线程池创建代码参考博客：https://blog.csdn.net/weixin_38956024/article/details/107892958 一、线程池主要函数说明 threadpool_t* threadpool_create(int min_thr_num, int max_thr_num, int queue_max_size) //创建一个线程池 //min_thr_
Linux多线程——线程池
Dirty_artist的博客
01-28 808
线程池、单例模式
【Linux学习】多线程——线程池 | 单例模式
weixin_63726869的博客
06-12 1999
介绍了线程池的意义，原理以及实现细节。还将线程池改造成了单例模式中的饿汉和懒汉模式。
c++学习——线程池
qq_42236622的博客
05-13 124
c++多线程之线程池学习
linux c/c++学习笔记
m0_37829435的博客
02-14 587
一、c基础问题 1.c各种基本数据类型是否由于操作系统的不同而不同？具体呢？ char short int float double long longlong (单位：字节)32位平台： 1 2 4 4 8 4 864位平台： 1 2 4 4 8 8 8注：对于各种数据类型，有符号和无符号所占字节一样，只不过有符号的最高位是符号位 2.为什么sigh char类型的127+1=-128？因为...
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码） 技术框架： 1. 线程池 + 非阻塞 socket + epoll + 事件处理的并发模型 2. 状态机解析HTTP请求 3. 心跳机制 4. 简易日志系统 主要内容： 1. ...
零声学院 第9代 Linux CC++后台架构开发 成长体系课程 - v1.21
08-03
【零声学院第九代Linux C/C++后台架构开发成长体系课程】是一门全面涵盖后台开发技术的高级课程，旨在帮助学员深入理解Linux环境下的后台架构设计与开发。课程内容丰富，涉及多个专题，包括算法与设计、后台组件编程...
课堂笔记_c++应用1
08-08
【C++线程池及其应用】 在C++编程中，线程池是一种高效利用系统资源、优化并发程序设计的技术。线程池的概念源于对象池设计模式，它的核心思想是预先创建一组线程，并将它们组织起来，以备后续任务调度使用，从而...
解决 Linux 和 Java 1.8 中上传中文名称图片报错问题
appearappear的博客
06-12 376
在 Linux 系统和 Java 1.8 中，当尝试上传含有中文名称的图片时，可能会遇到以下错误提示：为了解决这个问题，可以采取以下方法：在 Docker 的 中添加如下参数：Dockerfile使用以下命令启动 Java 程序，添加 参数：通过以上配置，确保了在启动 Java 程序时，使用了 UTF-8 编码，这样可以正确处理含有中文名称的文件，避免了报错问题的发生。3.5
Linux 6.10也引进了蓝屏机制
最新发布
bugsycrack的博客
06-19 81
Linux 6.10 还在开发之中，最新版本是 rc4，扩展 DRM Panic 支持的工作还在进行之中。未来在运行 Linux 6.10+ 的平台上，如果驱动支持 DRM Panic，那么就可以通过 echo c > /proc/sysrq-trigger 测试 Linux 版本的“蓝屏死机（BSOD）”。Linux 6.10 引入了一个新的 DRM Panic 处理程序基础设施，以便于在致命错误（Panic）发生时显示相关信息。
【Linux】进程间通信1——管道概念，匿名管道
2301_80224556的博客
06-16 1073
③写端进程将数据写完后将写端关闭。
linux写代码环境和工具
2301_80687320的博客
06-16 895
Linux作为一个自由和开放源码的操作系统，其环境具有高度的灵活性和可定制性。无论是在服务器、桌面应用、嵌入式系统还是云计算等领域，Linux都凭借其出色的性能和稳定性赢得了广泛的认可。本文将深入探讨Linux环境的构建、配置以及其对应用程序和系统性能的影响。一、Linux开发需要什么？1. 学习yum工具，进行软件安装2. 掌握vim编辑器使用，学会vim的简单配置3. 掌握gcc/g++编译器的使用，并了解其过程，原理4. 掌握简单gdb使用于调试。
[Linux] TCP协议介绍(3): TCP协议的“四次挥手“过程、状态分析...
七月.cc的博客
06-16 984
TCP协议是面向连接的, 面向字节流的, 可靠的 传输层协议...
linux， c++， 线程池 ， socket
04-01
在Linux系统中，使用C语言编写的程序通常会使用线程池和Socket来实现高效的并发通信。例如，可以使用线程池来管理多个网络连接，以及使用Socket来实现客户端和服务器之间的通信。同时，Linux系统提供了丰富的系统...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

酷帅且洋仔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值