【Linux:线程池】

news/2024/12/29 3:47:29/

文章目录

  • 1 线程池概念
  • 2 第一个版本的线程池
  • 3 第二个版本的线程池
  • 4 第三个版本的线程池
  • 5 STL中的容器以及智能指针的线程安全问题
  • 6 其他常见的各种锁
  • 7 读者写者问题(了解)

1 线程池概念

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

线程池的应用场景：

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

线程池示例：

    1. 创建固定数量线程池，循环从任务队列中获取任务对象，
    1. 获取到任务对象后，执行任务对象中的任务接口。

2 第一个版本的线程池

在创建线程池之前我们想想线程池的成员变量应该有哪些？首先我们需要一个容器来存放线程，所以不妨使用vector；还要使用一个整形变量来记录线程池中线程的个数；为了保证线程安全问题我们还得需要一把锁，同时为了维护同步关系我们还得需要一个条件变量(这里的同步关系是指当没有任务时线程库中的线程就休眠，当有任务时就执行任务)；另外我们还得需要一个任务队列。这里我们再封装一个任务类让等会儿验证时效果更加明显。

Task.hpp:

#pragma once
#include <iostream>
using namespace std;class Task
{
public:Task(int x=0, int y=0, char op='+'): _x(x), _y(y), _op(op){}void run(){switch (_op){case '+':_res = _x + _y;break;case '-':_res = _x - _y;break;case '*':_res = _x * _y;break;case '/': if(_y==0){_exitCode=1;return;}_res = _x / _y;break;case '%':_res = _x % _y;break;}}void formatMsk(){cout<<"mask:"<<_x<<_op<<_y<<"==?"<<endl;}void formatRes(){cout<<"res:"<<_x<<_op<<_y<<"=="<<_res<<endl;}private:int _x;int _y;char _op;int _res = 0;int _exitCode = 0;
};

现在我们来实现第一个版本：

#pragma once 
#include<iostream>
#include<vector>
#include<queue>
using namespace std;const int N=5;
template<class T>
class threadPool
{
public:threadPool(int sz=N):_sz(sz),_threads(sz){pthread_mutex_init(&_mutex,nullptr);pthread_cond_init(&_cond,nullptr);}static void* Routine(void* args)//用内存池的多线程执行任务{pthread_detach(pthread_self());//先让自己与主线程分离threadPool<T> *ptp=static_cast<threadPool<T> *>(args);while(true){pthread_mutex_lock(&(ptp->_mutex));while((ptp->_masks).empty()){pthread_cond_wait(&(ptp->_cond),&(ptp->_mutex));}T task=(ptp->_masks).front();(ptp->_masks).pop();pthread_mutex_unlock(&(ptp->_mutex));task.run();//在临界区外执行任务task.formatRes();}return nullptr;}void Start(){for(int i=0;i<_sz;++i){pthread_create(&_threads[i],nullptr,Routine,this);}}void PushTask(const T& task){pthread_mutex_lock(&_mutex);_masks.push(task);pthread_mutex_unlock(&_mutex);pthread_cond_signal(&_cond);//记得唤醒休眠的线程去执行任务}~threadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}vector<pthread_t> _threads;queue<T> _masks;int _sz;//线程池中线程的个数pthread_mutex_t _mutex;pthread_cond_t _cond;
};

这里面有几个特别需要注意的点：
在这里插入图片描述

  1. Routine我们实现的是static版本的，因为创建线程所要求的函数指针与类内成员函数不吻合，类内成员函数有this指针。
  2. 创建了线程后让该线程与主线程分离，也就是主线程不管新线程的资源回收了。
  3. 执行任务时要在临界区外执行，这样并发执行的效率才会更加高效。
  4. 为了方便使用将类中成员变量都搞成了公有，建议不要这样搞，可以自己写一个get。

至于其他的方面都很简单，相信大家能够很容易理解。
测试程序：

const char *ops = "+-*/%";int main()
{threadPool<Task> *threads = new threadPool<Task>(30);threads->Start();srand((size_t)time(nullptr));while (true){int x = rand() % 30 + 1;int y = rand() % 30 + 1;char op = ops[rand() % strlen(ops)];Task t(x, y, op);threads->PushTask(t);t.formatMsk();sleep(1);}return 0;
}

我们来运行下结果：
在这里插入图片描述

3 第二个版本的线程池

其实第二个版本的线程池与第一个的核心思路基本一致，主要是第二个版本使用的是我们自己模拟实现的创建线程的类，比如我们之前自己模拟实现(本质是封装了库中的线程库接口)的一份Thread.hpp:

#pragma once
#include <iostream>
#include <functional>
using namespace std;class threadProcess
{
public:enum stu{NEW,RUNNING,EXIT};template<class T>threadProcess(int num, T exe, void *args): _tid(0), _status(NEW),_exe(exe), _args(args){char name[26];snprintf(name, 26, "thread%d", num);_name = name;}static void* runHelper(void *args){threadProcess *ts = (threadProcess *)args; (*ts)();return nullptr;}void operator()() // 仿函数{if (_exe != nullptr)_exe(_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)exit(-1);_status = EXIT;}string _name;pthread_t _tid;stu _status;function<void*(void*)> _exe;void *_args;
};

这样我们自己就能够用自己的线程库来完成了：

#pragma once 
#include"Thread.hpp"
#include<iostream>
#include<vector>
#include<queue>
using namespace std;const int N=5;
template<class T>
class threadPool
{
public:threadPool(int sz=N):_sz(sz){pthread_mutex_init(&_mutex,nullptr);pthread_cond_init(&_cond,nullptr);}static void* Routine(void* args)//用内存池的多线程执行任务{//pthread_detach(pthread_self());调用自己写的线程接口不用在分离了，析构时在join掉就好了threadPool<T> *ptp=static_cast<threadPool<T> *>(args);while(true){pthread_mutex_lock(&(ptp->_mutex));while((ptp->_masks).empty()){pthread_cond_wait(&(ptp->_cond),&(ptp->_mutex));}T task=(ptp->_masks).front();(ptp->_masks).pop();pthread_mutex_unlock(&(ptp->_mutex));task.run();//在临界区外执行任务task.formatRes();}return nullptr;}void Init(){for(int i=0;i<_sz;++i){_threads.push_back(threadProcess(i+1,Routine,this));}}void Start(){for(auto& e:_threads){e.Run();}}void PushTask(const T& task){pthread_mutex_lock(&_mutex);_masks.push(task);pthread_mutex_unlock(&_mutex);pthread_cond_signal(&_cond);//记得唤醒休眠的线程去执行任务}~threadPool(){for(auto& e:_threads){e.Join();}pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}void Check(){for(auto& e:_threads){cout<<"name:"<<e._name<<" id"<<e._tid<<endl;}}vector<threadProcess> _threads;queue<T> _masks;int _sz;//线程池中线程的个数pthread_mutex_t _mutex;pthread_cond_t _cond;
};

测试代码：

int main()
{threadPool<Task> *threads = new threadPool<Task>(8);threads->Init();threads->Start();srand((size_t)time(nullptr));while (true){int x = rand() % 30 + 1;int y = rand() % 30 + 1;char op = ops[rand() % strlen(ops)];Task t(x, y, op);threads->PushTask(t);t.formatMsk();sleep(1);}return 0;
}

运行结果：
在这里插入图片描述

4 第三个版本的线程池

这个版本的线程池在前面版本的基础上加了一个单例模式。因为我们发现其实线程池只需要一个就可以了，我们使用懒汉模式来创建单例。

代码实现：

#pragma once
#include "Thread.hpp"
#include <iostream>
#include <vector>
#include <queue>
using namespace std;const int N = 5;
template <class T>
class threadPool
{
public:static threadPool<T>* GetInstance(int sz=N){if(_sta_obj==nullptr){pthread_mutex_lock(&_mutex);if(_sta_obj==nullptr){_sta_obj=new threadPool<T>(sz);}pthread_mutex_unlock(&_mutex);}}static void *Routine(void *args) // 用内存池的多线程执行任务{// pthread_detach(pthread_self());调用自己写的线程接口不用在分离了，析构时在join掉就好了threadPool<T> *ptp = static_cast<threadPool<T> *>(args);while (true){pthread_mutex_lock(&(ptp->_mutex));while ((ptp->_masks).empty()){pthread_cond_wait(&(ptp->_cond), &(ptp->_mutex));}T task = (ptp->_masks).front();(ptp->_masks).pop();pthread_mutex_unlock(&(ptp->_mutex));task.run(); // 在临界区外执行任务task.formatRes();}return nullptr;}void Init(){for (int i = 0; i < _sz; ++i){_threads.push_back(threadProcess(i + 1, Routine, this));}}void Start(){for (auto &e : _threads){e.Run();}}void PushTask(const T &task){pthread_mutex_lock(&_mutex);_masks.push(task);pthread_mutex_unlock(&_mutex);pthread_cond_signal(&_cond); // 记得唤醒休眠的线程去执行任务}~threadPool(){for (auto &e : _threads){e.Join();}pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}void Check(){for (auto &e : _threads){cout << "name:" << e._name << " id" << e._tid << endl;}}vector<threadProcess> _threads;queue<T> _masks;int _sz; // 线程池中线程的个数pthread_mutex_t _mutex;pthread_cond_t _cond;private:threadPool(int sz = N): _sz(sz){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_cond, nullptr);}threadPool(const threadPool<T>& th)=delete;threadPool<T>& operator=(const threadPool<T>& th)=delete;static threadPool<T>* _sta_obj;
};
template<class T>
threadPool<T>* threadPool<T>::_sta_obj=nullptr;

其中注意点：
在这里插入图片描述
在加锁时为了高效我们是用了双重if条件判断。

在这里插入图片描述
注意将构造函数搞成了私有，拷贝构造和拷贝赋值都删掉了。

5 STL中的容器以及智能指针的线程安全问题

STL中的容器是否是线程安全的?

不是。原因是, STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响.而且对于不同的容器, 加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶).因此 STL 默认不是线程安全. 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全。

智能指针是否是线程安全的?

对于 unique_ptr, 由于只是在当前代码块范围内生效, 因此不涉及线程安全问题。
对于 shared_ptr, 多个对象需要共用一个引用计数变量, 所以会存在线程安全问题. 但是标准库实现的时候考虑到了这个问题, 基于原子操作(CAS)的方式保证 shared_ptr 能够高效, 原子的操作引用计数。

6 其他常见的各种锁

  • 悲观锁：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。
  • 乐观锁：每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式：版本号机制和CAS操作。CAS操作：当需要更新数据时，判断当前内存值和之前取得的值是否相等。如果相等则用新值更新。若不等则失败，失败则重试，一般是一个自旋的过程，即不断重试。
  • 自旋锁，公平锁，非公平锁。

7 读者写者问题(了解)

读写锁:
在编写多线程的时候，有一种情况是十分常见的。那就是，有些公共数据修改的机会比较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。那么有没有一种方法，可以专门处理这种多读少写的情况呢？ 有，那就是读写锁。

读写锁的行为：

当前锁的状态读锁请求写锁请求
无锁可以可以
读锁可以阻塞
写锁阻塞阻塞
  • 注意：写独占，读共享，读锁优先级高

http://www.ppmy.cn/news/1009123.html

相关文章

【探索Linux】—— 步步学习强大的命令行工具 P.1（Linux简介）

【探索Linux】—— 步步学习强大的命令行工具 P.1（Linux简介）

目录 前言 一、Linux简介 二、linux的不同发行版本 三、Linux的开源性质 四、Linux的特点 五、Linux代码演示&#xff08;仅供参考&#xff09; 总结 前言 前面我们讲了C语言的基础知识&#xff0c;也了解了一些数据结构&#xff0c;并且讲了有关C的一些知识&#xff…
阅读更多...
Vivado使用入门之一:Schematic图

Vivado使用入门之一:Schematic图

目录 一、前言 二、Schematic类型 2.1 Schematic分类 2.2 RTL ANALYSIS 2.3 SYSTHESIS 2.4 IMPLEMENTATION 三、Schematic功能 3.1 界面工具栏 3.2 右键功能项对比 3.3 右键功能项说明 3.4 逻辑图界面 一、前言 在一个设计中&#xff0c;有时因定位或其他原因需要去查…
阅读更多...
并查集练习 —岛屿数量（解法一）

并查集练习 —岛屿数量（解法一）

题目&#xff1a; 给定一个二维数组matrix&#xff08;char[][]&#xff09;&#xff0c;里面的值不是1就是0&#xff0c;上、下、左、右相邻的1认为是一片岛。返回matrix中岛的数量。 本题共有2种解法&#xff0c;本篇先介绍最快的一种解法—递归。 分析&#xff1a; 递归的方…
阅读更多...
第三章 关系数据库标准语言SQL

第三章 关系数据库标准语言SQL

结构化查询语言&#xff08;Structed Query Language,SQL&#xff09;是关系数据库的标准语言&#xff0c;也是一个通用的&#xff0c;功能极强的关系数据库语言。 其功能不仅是查询&#xff0c;而且包括数据库模式创建&#xff0c;数据库数据的插入和修改&#xff0c;数据库安…
阅读更多...
Modelsim打开后报unable to checkout a viewer license

Modelsim打开后报unable to checkout a viewer license

找到Modelsim安装包中的MentorKG.exe文件和patch64_dll.bat文件&#xff0c;将这两个文件拷贝到Modelsim安装目录中的win64文件夹&#xff1a; 在win64文件夹中找到mgls64.dll&#xff0c;将它拷贝粘贴一份后修改名字为mgls.dll&#xff1a; 双击win64文件夹中的patch64_dll.ba…
阅读更多...
SAP-FI-发票校验-总账科目录

SAP-FI-发票校验-总账科目录

1、业务场景 （1）如果某司机是按月结账，没有参照PO，而且每次记账的科目都不同，可能是办公费、原材料费，那么就需要直接记账到某一科目，输入基本数据的“CNY”，细节的“发票方”。 （2）如果项目期初上线，物料已收货，但是没有开票，不需要收货到系统，收到发票后，因…
阅读更多...
【C#】.Net Framework框架下使用SQLike以及基本概念

【C#】.Net Framework框架下使用SQLike以及基本概念

2023年&#xff0c;第32周&#xff0c;第2篇文章。给自己一个目标&#xff0c;然后坚持总会有收货&#xff0c;不信你试试&#xff01; 在C#的.NET Framework框架下&#xff0c;有很多轻量级数据库选择&#xff0c;比如&#xff1a;SQLike就是其中一款&#xff0c;一起来了解SQ…
阅读更多...
C++——new delete

C++——new delete

本文主要介绍C中的new和delete&#xff0c;用于内存的申请和释放 1. 变量 示例 void variableFunc() //变量的使用 {int* ptr new int;*ptr 100;std::cout<<"ptr value is: "<<*ptr<<std::endl;delete ptr; //释放 }ptr 是一个指向 int 类…
阅读更多...
最新文章

Copyright @ 2022~2023