【Linux】线程池的简易实现（懒汉模式）

文章目录

  • 前言
  • 一、懒汉方式
    • 1.普通模式
    • 1.线程安全模式
  • 二、源代码
    • 1.Task.hpp(要执行的任务)
    • 2.ThreadPool.hpp(线程池)
    • 3.Main.cpp

前言

`

线程池:
一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。

  • 线程池的应用场景：
    1. 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技 术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个 Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
    1. 对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
    1. 接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情 况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限， 出现错误.

一、懒汉方式

1.普通模式

懒汉方式实现单例模式

template <typename T>
class Singleton {
static T* inst;
public:
static T* GetInstance() {
if (inst == NULL) {
inst = new T();
}
return inst;
}
};

1.线程安全模式

存在一个严重的问题, 线程不安全.
第一次调用 GetInstance 的时候, 如果两个线程同时调用, 可能会创建出两份 T 对象的实例.
但是后续再次调用, 就没有问题了.

// 懒汉模式, 线程安全
template <typename T>
class Singleton {
volatile static T* inst; // 需要设置 volatile 关键字, 否则可能被编译器优化.
static std::mutex lock;
public:
static T* GetInstance() {
if (inst == NULL) { // 双重判定空指针, 降低锁冲突的概率, 提高性能.
lock.lock(); // 使用互斥锁, 保证多线程情况下也只调用一次 new.
if (inst == NULL) {
inst = new T();
}
lock.unlock();
}
return inst;
}
};

注意事项:
1. 加锁解锁的位置
2. 双重 if 判定, 避免不必要的锁竞争
3. volatile关键字防止过度优化

二、源代码

1.Task.hpp(要执行的任务)

可根据自己的需求修改要执行的任务，这里我们以进行两个数的加减乘除为例子

#pragma once
#include <iostream>
#include <string>
std::string opers = "+-*/%";//运算符号

enum//返回值
{
    DivZero = 1,
    ModZero,
    Unknown
};

class Task
{
public:
    Task()
    {
    }

    Task(int x, int y, char op) : data1_(x), data2_(y), oper_(op), result_(0), exitcode_(0)
    {
    }

    void run()
    {
        switch (oper_)
        {
        case '+':
            result_ = data1_ + data2_;
            break;
        case '-':
            result_ = data1_ - data2_;
            break;
        case '*':
            result_ = data1_ * data2_;
            break;
        case '/':
        {
            if (data2_ == 0)
                exitcode_ = DivZero;
            else
                result_ = data1_ / data2_;
        }
        break;
        case '%':
        {
            if (data2_ == 0)
                exitcode_ = ModZero;
            else
                result_ = data1_ % data2_;
        }
        break;
        default:
            exitcode_ = Unknown;
            break;
        }
    }

    void operator()()//直接使用仿函数，调用run方法
    {
        run();
    }

    std::string GetResult()
    {
        std::string r = std::to_string(data1_);
        r += oper_;
        r += std::to_string(data2_);
        r += "=";
        r += std::to_string(result_);
        r += "[code: ";
        r += std::to_string(exitcode_);
        r += "]";

        return r;
    }
    std::string GetTask()
    {
        std::string r = std::to_string(data1_);
        r += oper_;
        r += std::to_string(data2_);
        r += "=?";
        return r;
    }
    ~Task()
    {
    }

private:
    int data1_;
    int data2_;

    char oper_;

    int result_;
    int exitcode_;
};

2.ThreadPool.hpp(线程池)

#pragma once

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

struct ThreadInfo//线程信息
{
    pthread_t tid;
    std::string name;
};

static const int defalutnum = 5;//默认创建线程个数

template <class T>
class ThreadPool
{
public:
    void Lock()
    {
        pthread_mutex_lock(&mutex_);
    }
    void Unlock()
    {
        pthread_mutex_unlock(&mutex_);
    }
    void Wakeup()
    {
        pthread_cond_signal(&cond_);
    }
    void ThreadSleep()
    {
        pthread_cond_wait(&cond_, &mutex_);
    }
    bool IsQueueEmpty()
    {
        return tasks_.empty();
    }
    std::string GetThreadName(pthread_t tid)
    {
        for (const auto &ti : threads_)
        {
            if (ti.tid == tid)
                return ti.name;
        }
        return "None";
    }

public:
    static void *HandlerTask(void *args)
    //这里需要用静态函数，因为在类中默认隐藏一个this指针
    {
        //这里传args直接把ThreadPool这个类传入进来进行操作
        //这样既能访问类中的方法也能符合传入的参数个数为1个的规则
        ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
        std::string name = tp->GetThreadName(pthread_self());
        while (true)
        {
            tp->Lock();

            while (tp->IsQueueEmpty())
            //循环判断，防止线程的伪唤醒
            {
                tp->ThreadSleep();
            }
            T t = tp->Pop();
            tp->Unlock();

            t();//直接调用任务的处理方法（仿函数）
            std::cout << name << " run, "
                      << "result: " << t.GetResult() << std::endl;
        }
    }
    void Start()//启动线程池
    {
        int num = threads_.size();
        for (int i = 0; i < num; i++)
        {
            //创建线程并且给线程池命名
            threads_[i].name = "thread-" + std::to_string(i + 1);
            pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);
        }
    }
    T Pop()
    {
        T t = tasks_.front();
        tasks_.pop();
        return t;
    }
    void Push(const T &t)
    {
        Lock();
        tasks_.push(t);
        Wakeup();//队列中有了数据
        //可能在之前任务为空的时候有线程进入了休眠
        //所以放入任务后，进行一次唤醒操作
        Unlock();
    }
    static ThreadPool<T> *GetInstance()
    {
        if (nullptr == tp_) 
        // 双重判定空指针, 降低锁冲突的概率, 提高性能.
        {
            pthread_mutex_lock(&lock_);
            //这个lock_锁为静态成员
            if (nullptr == tp_)
            {
                std::cout << "log: singleton create done first!" << std::endl;
                tp_ = new ThreadPool<T>();
            }
            pthread_mutex_unlock(&lock_);
        }

        return tp_;
    }

private:
//因为为懒汉单例模式，只有一个ThreadPool类，所以为了避免
//冲突，把构造函数，拷贝构造函数都设置成私有禁用
    ThreadPool(int num = defalutnum) : threads_(num)
    {
        pthread_mutex_init(&mutex_, nullptr);
        pthread_cond_init(&cond_, nullptr);
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&mutex_);
        pthread_cond_destroy(&cond_);
    }
    ThreadPool(const ThreadPool<T> &) = delete;
    const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
private:
    std::vector<ThreadInfo> threads_;
    std::queue<T> tasks_;

    pthread_mutex_t mutex_;
    pthread_cond_t cond_;

    static ThreadPool<T> *tp_;//懒汉单例模式所创建的
    //唯一的ThreadPool类
    static pthread_mutex_t lock_;
    //静态方法只能访问类中的静态成员，所以还需要一个静态锁在
    //获取这个对象的时候使用(GetInstance)
};

//静态成员在类外进行初始化
template <class T>
ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;

template <class T>
pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;

3.Main.cpp

#include <iostream>
#include <ctime>
#include "ThreadPool.hpp"
#include "Task.hpp"


pthread_spinlock_t slock;


int main()
{
     
     
    std::cout << "process runn..." << std::endl;
    sleep(3);
    //GetInstance()获取单例对象
    ThreadPool<Task>::GetInstance()->Start();
    srand(time(nullptr) ^ getpid());

    while(true)
    {
        //1. 构建任务
        int x = rand() % 10 + 1;
        usleep(10);
        int y = rand() % 5;
        char op = opers[rand()%opers.size()];

        Task t(x, y, op);
        ThreadPool<Task>::GetInstance()->Push(t);
        //2. 交给线程池处理
        std::cout << "main thread make task: " << t.GetTask() << std::endl;

        sleep(1);
    }
}

在这里插入图片描述

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

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

相关文章

【Qt】—— Qt Creator 创建项目

【Qt】—— Qt Creator 创建项目

目录 &#xff08;一&#xff09;Qt Creator概览 &#xff08;二&#xff09;使⽤Qt Creator新建项⽬ &#xff08;一&#xff09;Qt Creator概览 从开始菜单或者快捷⽅式打开Qt Creator集成开发环境&#xff0c;启动之后看到类似下⾯的界⾯&#xff1a; 【解释说明】 菜单栏…
阅读更多...
一体化设计：兼容多种OS系统Linux网关楼宇DDC

一体化设计：兼容多种OS系统Linux网关楼宇DDC

在工业物联网&#xff08;IIoT&#xff09;和智能建筑领域&#xff0c;钡铼网关具备高度灵活性与强大计算能力的边缘网关产品正逐渐成为推动行业智能化转型的关键要素。本文将详细介绍的基于Linux系统的4G工业智能网关&#xff0c;不仅拥有NXP i.MX8M Mini四核64位处理器的强大…
阅读更多...
容器算法迭代器初识

容器算法迭代器初识

#include<iostream> using namespace std; #include<vector> //vetor容器存放内置数据类型 void test01() {//创建了一个vector容器&#xff0c;数组 vector<int> v;//向容器中插入数据v.push_back (10);//尾插 v.push_back (20);v.push_back (30);v.push_ba…
阅读更多...
Springboot使用数据库连接池druid

Springboot使用数据库连接池druid

springboot框架中可以使用druid进行数据库连接池&#xff0c;下面介绍druid在springboot中使用和参数配置介绍。 数据库连接池&#xff08;Druid&#xff09;是一种用于管理数据库连接的机制&#xff0c;其工作原理和常见使用方法如下&#xff1a; 原理&#xff1a;数据库连接…
阅读更多...
异步任务的一些思考

异步任务的一些思考

前言 XXL-Job部署教程 项目中&#xff0c;必然少不了数据的导入导出&#xff0c;针对数据的导入导出简单复盘一下。 为了不占用资源消耗时间&#xff0c;影响用户体验&#xff0c;大量数据的导入导出一般都是异步执行 导入的时候&#xff0c;如果数据量很大&#xff0c;一次…
阅读更多...
C#使用RabbitMQ-4_路由模式（直连交换机）

C#使用RabbitMQ-4_路由模式（直连交换机）

简介 RabbitMQ中的路由模式是一种根据Routing Key有条件地将消息筛选后发送给消费者的模式。在路由模式中&#xff0c;生产者向交换机发送消息时&#xff0c;会指定一个Routing Key。交换机接收生产者的消息后&#xff0c;根据消息的Routing Key将其路由到与Routing Key完全匹…
阅读更多...
Centos7——下载——安装

Centos7——下载——安装

解释 CentOS 7是CentOS项目发布的开源类服务器操作系统&#xff0c;于2014年7月7日正式发布。CentOS 7是一个企业级的Linux发行版本&#xff0c;它源于RedHat免费公开的源代码进行再发行。CentOS 7内核更新至3.10.0、支持Linux容器、支持Open VMware Tools及3D图像即装即用、支…
阅读更多...
代码随想录算法训练营第二二天| 二叉搜索树的最近公共祖先、二叉搜索树中的插入操作、删除二叉搜索树中的节点

代码随想录算法训练营第二二天| 二叉搜索树的最近公共祖先、二叉搜索树中的插入操作、删除二叉搜索树中的节点

目录 二叉搜索树的最近公共祖先二叉搜索树中的插入操作删除二叉搜索树中的节点普通二叉树的删除方式 LeetCode 235. 二叉搜索树的最近公共祖先 LeetCode 701.二叉搜索树中的插入操作 LeetCode 450.删除二叉搜索树中的节点 二叉搜索树的最近公共祖先 给定一个二叉搜索树, 找到…
阅读更多...
【Linux】多线程（线程概念+线程控制）

【Linux】多线程（线程概念+线程控制）

&#x1f307;个人主页&#xff1a;平凡的小苏 &#x1f4da;学习格言&#xff1a;命运给你一个低的起点&#xff0c;是想看你精彩的翻盘&#xff0c;而不是让你自甘堕落&#xff0c;脚下的路虽然难走&#xff0c;但我还能走&#xff0c;比起向阳而生&#xff0c;我更想尝试逆风…
阅读更多...
Bootloader简单说明

Bootloader简单说明

文章目录 一、简单架构1.CAN驱动2.Flash驱动3.传输层4.诊断层5.看门狗&#xff08;Watch Dog&#xff09;6.加密算法 二、主要功能三、启动顺序与转换流程1.启动流程图2.启动顺序与转换流程说明 一、简单架构 1.CAN驱动 实现CAN报文的收发和CAN控制器硬件的操作。特点&#x…
阅读更多...
C++20 高级编程

C++20 高级编程

文章目录 前言前奏lambda浅谈std::ref的实现浅谈is_same浅谈std::function的实现std::visit 与 std::variant 与运行时多态SFINAE类型内省标签分发 (tag dispatching)编译时多态奇异递归模板模式 (Curiously Recurring Template Pattern,CRTP) 三路比较操作符 (飞船操作符) <…
阅读更多...
蓝桥杯2024/1/28----十二届省赛题笔记

蓝桥杯2024/1/28----十二届省赛题笔记

题目要求&#xff1a; 2、 竞赛板配置要求 2.1将 IAP15F2K61S2 单片机内部振荡器频率设定为 12MHz。 2.2键盘工作模式跳线 J5 配置为 KBD 键盘模式。 2.3扩展方式跳线 J13 配置为 IO 模式。 2.4 请注意 &#xff1a; 选手需严格按照以上要求配置竞赛板&#xff0c;编写和调…
阅读更多...
C语言基础13

C语言基础13

今天是学习嵌入式相关内容的第十四天&#xff0c;以下是今日所学内容 1.结构体: 1.结构体类型定义 2.结构体变量的定义 3.结构体元素的访问 4.结构体的存储 内存对齐 结构体整体的大小必须为最大基本类型长度的整数倍 5.结构体作为函数参数 值传递 练习:定…
阅读更多...
数据中心IP代理是什么？有何优缺点？海外代理IP全解

数据中心IP代理是什么？有何优缺点？海外代理IP全解

海外代理IP中&#xff0c;数据中心代理IP是很热门的选择。这些代理服务器为用户分配不属于 ISP&#xff08;互联网服务提供商&#xff09;且来自第三方云服务提供商的 IP 地址&#xff0c;是分配给位于数据中心的服务器的 IP 地址&#xff0c;通常由托管和云公司拥有。 这些 I…
阅读更多...
使用Huggingface镜像站hf-mirror.com下载资源

使用Huggingface镜像站hf-mirror.com下载资源

前言 在使用Huggingface的过程中&#xff0c;有时我们可能会遇到无法访问官方网站huggingface.co的情况&#xff0c;这可能是由于网络监管或者网络连接问题所致。然而&#xff0c;幸运的是&#xff0c;我们可以通过hf-mirror.com这个Huggingface镜像站来解决这个问题。本篇博客…
阅读更多...
shell脚本之多行重定向 免交互 expect ssh scp； 字符处理

shell脚本之多行重定向 免交互 expect ssh scp； 字符处理

多行重定向 使用I/O重定向的方式将命令列表提供给交互式程序 标准输入的一种替代品 Here Document 是标准输 入的一种替代品&#xff0c;可以帮助脚本开发人员不必使用临时文件来构建输入信息&#xff0c;而是直接就地 生产出一个文件并用作命令的标准输入,Here Document 可…
阅读更多...
TypeScript（十） Map对象、元组、联合类型、接口

TypeScript（十） Map对象、元组、联合类型、接口

1. Map对象 1.1. 简述 Map对象保存键值对&#xff0c;并且能够记住键的原始插入顺序。   任何值都可以作为一个键或一个值。 1.2. 创建 Map 使用Map类型和new 关键字来创建Map&#xff1a; 如&#xff1a; let myMap new Map([["key1", "value1"],[&…
阅读更多...
Prometheus---图形化界面grafana(二进制)

Prometheus---图形化界面grafana(二进制)

前言 Prometheus是一个开源的监控以及报警系统。整合zabbix的功能&#xff0c;系统&#xff0c;网络&#xff0c;设备。 proetheus可以兼容网络&#xff0c;设备。容器的监控。告警系统。因为他和k8s是一个项目基金开发的产品&#xff0c;天生匹配k8s的原生系统。容器化和云原…
阅读更多...
iOS App审核状态和审核时间管理指

iOS App审核状态和审核时间管理指

引言 对于一款开发完成并准备上架的 iOS 应用程序来说&#xff0c;通过苹果公司的审核是非常重要的一步。苹果公司会对应用程序进行严格的检查&#xff0c;以确保应用程序的质量和安全性。本文将介绍 iOS 应用程序审核的流程和时间&#xff0c;希望能够帮助开发者更好地了解和…
阅读更多...
《Is dataset condensation a silver bullet for healthcare data sharing?》

《Is dataset condensation a silver bullet for healthcare data sharing?》

一篇数据浓缩在医疗数据集应用中的论文。 其实就是在医疗数据集上使用了data condensation的方法&#xff0c;这里使用了DM的方式&#xff0c;并且新增了浓缩时候使用不同的网络。 1. 方法 数据浓缩DC的目的是&#xff1a; E x ∼ P D [ L ( φ θ O ( x ) , y ) ] ≃ E x ∼…
阅读更多...
最新文章

Copyright @ 2022~2023