单例模式与锁(死锁)

目录

线程安全的单例模式

什么是单例模式

单例模式的特点  

饿汉实现方式和懒汉实现方式

饿汉⽅式实现单例模式

懒汉⽅式实现单例模式

懒汉⽅式实现单例模式(线程安全版本)

单例式线程池

ThreadPool.hpp

threadpool.cc

运行结果

线程安全和重⼊问题

常⻅锁概念

死锁

死锁四个必要条件

避免死锁

破坏死锁的四个必要条件 

避免死锁算法

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

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

其他常⻅的各种锁

线程安全的单例模式

什么是单例模式

单例模式的特点  

某些类, 只应该具有⼀个对象(实例), 就称之为单例.

例如⼀个男⼈只能有⼀个媳妇. 在很多服务器开发场景中, 经常需要让服务器加载很多的数据(上百G) 到内存中. 此时往往要⽤⼀个单例的类来管理这些数据.

单例模式 分为饿汉模式和懒汉模式

饿汉实现方式和懒汉实现方式

[洗碗的例⼦]

吃完饭, ⽴刻洗碗, 这种就是饿汉⽅式. 因为下⼀顿吃的时候可以⽴刻拿着碗就能吃饭.

吃完饭, 先把碗放下, 然后下⼀顿饭⽤到这个碗了再洗碗, 就是懒汉⽅式.

饿汉模式: 直接准备好

懒汉模式: 用时才准备,延时加载        例如: 写时拷贝 ,new malloc 中真实物理空间的加载

懒汉方式最核心的思想是 "延时加载". 从而能够优化服务器的启动速度.

饿汉⽅式实现单例模式

template <typename T>
class Singleton 
{static T data;
public:static T* GetInstance() {return &data;}
};

只要通过Singleton 这个包装类来使⽤ T 对象,则⼀个进程中只有⼀个T对象的实例.

懒汉⽅式实现单例模式

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

存在⼀个严重的问题, 线程不安全.

第⼀次调⽤ 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关键字防⽌过度优化

单例式线程池

ThreadPool.hpp

#pragma once
#include <queue>
#include <iostream>
#include <string>
#include <vector> //用vector管理线程
#include <memory>
#include "log.hpp"
#include "Thread.hpp"
#include "Mutex.hpp"
#include "Cond.hpp"namespace ThreadPoolModule
{using namespace LockModule;using namespace ThreadModule;using namespace CondModule;using namespace LogModule;const static int defaultnum = 5;using thread_t = std::shared_ptr<Thread>;void Defaulttest(){while (true){LOG(LogLevel::INFO) << "test";sleep(1);}}template <typename T>class ThreadPool{private:bool IsEmpty(){return _taskq.empty();}// 执行任务void HandlerTask(std::string name){LOG(LogLevel::INFO)<<"线程"<< name <<"进入handlerTask";// 线程醒来就一直执行while (true){T t;{LockGuard lockguard(_mutex);while (IsEmpty() && _isrunning){_wait_num++;_cond.Wait(_mutex);_wait_num--;}// 任务队列为空 && 线程池退出了才退出    ,重要重要 if(IsEmpty() && !_isrunning)break;// 1.拿任务t = _taskq.front();_taskq.pop();}//在临界区外 ,处理任务 ,效率更高// 2.处理任务   规定传入的所有的任务, 必须提供()方法t(name);}LOG(LogLevel::INFO) << "线程: " << name << " 退出";}ThreadPool(const ThreadPool<T> &) = delete;//拷贝构造禁掉ThreadPool<T>& operator=(const ThreadPool<T> &) = delete;//赋值重载禁掉ThreadPool(int num = defaultnum) //构造函数设为私有: _num(num),_wait_num(0),_isrunning(false){// 创建num个线程for (int i = 0; i < num; i++){//bind  此时所有创建出来的线程,转而去执行HandlerTask_threads.push_back(std::make_shared<Thread>(std::bind(&ThreadPool::HandlerTask, this,std::placeholders::_1 )));LOG(LogLevel::INFO) << "构建线程" << _threads.back()->Name() << "成功";}}public:static ThreadPool<T> * getInstance() //单例模式{if(_instance == NULL){LockGuard lockguard(_mutex_singleton);if(_instance == NULL){LOG(LogLevel::INFO) << "单例首次被执行，需要加载对象...";_instance = new ThreadPool<T>();}}return _instance;}~ThreadPool(){}void Start(){if(_isrunning) return;_isrunning = true; // bug fix??for (auto &thread_ptr : _threads){thread_ptr->Start();LOG(LogLevel::INFO) << "启动线程" << thread_ptr->Name() << "成功";}}void Wait(){for (auto &thread_ptr : _threads){thread_ptr->Join();LOG(LogLevel::INFO) << "回收线程" << thread_ptr->Name() << "成功";}}//任务入队列void Enqueue(T &&in)//这个会被多线程调用 ,先加锁{//只要队列扛得住 ,就一直加LockGuard lockguard(_mutex);if(!_isrunning) return;_taskq.push(std::move(in));if(_wait_num > 0 ) _cond.Notify();}//退出线程池void Stop(){LockGuard lockguard(_mutex);if(_isrunning){// 3. 不能在入任务了_isrunning = false; // 不工作// 1. 让线程自己退出(要唤醒) && // 2. 历史的任务被处理完了if(_wait_num>0)_cond.NotifyAll();}}private:int _num;                       // 线程个数std::queue<T> _taskq;           // 任务队列  是临界资源std::vector<thread_t> _threads; // 管理线程 ,其中是线程的指针Mutex _mutex;Cond _cond;int _wait_num;bool _isrunning ;               //线程池的运行状态static ThreadPool<T>* _instance; //单例模式的静态指针static Mutex _mutex_singleton;//只用来保护单例};//静态方法初始化应放在类外template<typename T>ThreadPool<T> *ThreadPool<T>::_instance = NULL;template<typename T>Mutex ThreadPool<T>::_mutex_singleton; //只用来保护单例
}

threadpool.cc

#include"ThreadPool.hpp"
#include<memory>
#include"Task.hpp"
using namespace ThreadPoolModule;int main()
{ENABLE_CONSOLE_LOG();ThreadPool<task_t>::getInstance()->Start();char c;int cnt = 5;while (cnt){// std::cin >> c;ThreadPool<task_t>::getInstance()->Enqueue(Push);cnt--;sleep(1);}ThreadPool<task_t>::getInstance()->Stop();ThreadPool<task_t>::getInstance()->Wait();
}

运行结果

线程安全和重⼊问题

线程安全描述的是线程

重入描述的是函数

线程安全：

就是多个线程在访问共享资源时，能够正确地执⾏，不会相互⼲扰或破坏彼此的执⾏结果。⼀般⽽⾔，多个线程并发同⼀段只有局部变量的代码时，不会出现不同的结果。但是对全局变量或者静态变量进⾏操作，并且没有锁保护的情况下，容易出现该问题。

重⼊：

同⼀个函数被不同的执⾏流调⽤，当前⼀个流程还没有执⾏完，就有其他的执⾏流再次进⼊， 我们称之为重⼊。⼀个函数在重⼊的情况下，运⾏结果不会出现任何不同或者任何问题，则该函数被 称为可重⼊函数，否则，是不可重⼊函数。

重⼊其实可以分为两种情况

  • 多线程重⼊函数
  • 信号导致⼀个执⾏流重复进⼊函数

常⻅锁概念

死锁

  • 死锁是指在⼀组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所占用不会释放的资源⽽处于的⼀种永久等待状态。
  • 为了方便表述，假设现在线程A，线程B必须同时持有锁1和锁2，才能进⾏后续资源的访问

申请⼀把锁是原⼦的，但是申请两把锁就不⼀定了

造成的结果是

死锁四个必要条件

  • 互斥条件：⼀个资源每次只能被⼀个执⾏流使用
  • 请求与保持条件：⼀个执⾏流因请求资源⽽阻塞时，对已获得的资源保持不放
  • 不剥夺条件:⼀个执⾏流已获得的资源，在末使⽤完之前，不能强⾏剥夺
  • 循环等待条件:若⼲执⾏流之间形成⼀种头尾相接的循环等待资源的关系

避免死锁

破坏死锁的四个必要条件 

破坏循环等待条件问题：资源⼀次性分配，使⽤超时机制、加锁顺序⼀致

// 下⾯的C++不写了，理解就可以 
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <unistd.h>
// 定义两个共享资源（整数变量）和两个互斥锁 
int shared_resource1 = 0;
int shared_resource2 = 0;
std::mutex mtx1, mtx2;// ⼀个函数，同时访问两个共享资源 
void access_shared_resources()
{// std::unique_lock<std::mutex> lock1(mtx1, std::defer_lock);// std::unique_lock<std::mutex> lock2(mtx2, std::defer_lock);// // 使⽤ std::lock 同时锁定两个互斥锁 // std::lock(lock1, lock2);// 现在两个互斥锁都已锁定，可以安全地访问共享资源 int cnt = 10000;while (cnt){++shared_resource1;++shared_resource2;cnt--;}// 当离开 access_shared_resources 的作⽤域时，lock1 和 lock2 的析构函数会被⾃动调⽤ // 这会导致它们各⾃的互斥量被⾃动解锁 
}// 模拟多线程同时访问共享资源的场景 
void simulate_concurrent_access()
{std::vector<std::thread> threads;// 创建多个线程来模拟并发访问 for (int i = 0; i < 10; ++i){threads.emplace_back(access_shared_resources);}// 等待所有线程完成 for (auto &thread : threads){thread.join();}// 输出共享资源的最终状态 std::cout << "Shared Resource 1: " << shared_resource1 << std::endl;std::cout << "Shared Resource 2: " << shared_resource2 << std::endl;
}int main()
{simulate_concurrent_access();return 0;
}

$ ./a.out // 不⼀次申请 
Shared Resource 1: 94416
Shared Resource 2: 94536$ ./a.out // ⼀次申请 
Shared Resource 1: 100000
Shared Resource 2: 100000

避免死锁算法

  • 死锁检测算法
  • 银⾏家算法

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

不安全.

原因是, STL 的设计初衷是将性能挖掘到极致, ⽽⼀旦涉及到加锁保证线程安全, 会对性能造成巨⼤的影响.  ⽽且对于不同的容器, 加锁⽅式的不同, 性能可能也不同(例如hash表的锁表和锁桶). 因此 STL 默认不是线程安全.

如果需要在多线程环境下使⽤, 往往需要调⽤者⾃⾏保证线程安全.

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

智能指针是安全的,指针指向的对象不一定.

对于 unique_ptr, 由于只是在当前代码块范围内⽣效, 因此不涉及线程安全问题.

对于 shared_ptr, 多个对象需要共⽤⼀个引⽤计数变量, 所以会存在线程安全问题. 但是标准库实现的时 候考虑到了这个问题, 基于原⼦操作(CAS)的⽅式保证 shared_ptr 能够⾼效, 原⼦的操作引⽤计数.

其他常⻅的各种锁

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

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

CSS标题下划线动态进入和移开

CSS标题下划线动态进入和移开

<!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>CSS动态效果</title><style>div .title…
阅读更多...
软件工程 期末复习

软件工程 期末复习

瀑布模型&#xff1a;计划 螺旋模型&#xff1a;风险低 原型模型: 用户反馈 喷泉模型:代码复用 高内聚 低耦合&#xff1a;模块内部功能紧密 模块之间依赖程度小 高内聚&#xff1a;指的是一个模块内部的功能应该紧密相关。换句话说&#xff0c;一个模块应当只实现单一的功能…
阅读更多...
鸿蒙 Stege模型 多模块应用

鸿蒙 Stege模型 多模块应用

模块 一个鸿蒙应用可能包含一个或者多个功能模块&#xff0c;在 DevEcoStudio 工程中可以创建对应的一个或多个 Module。Module 又分为 “Ability” 和 “Library”两种类型&#xff0c;“Ability”类型的 Module 对应于编译后的 HAP&#xff08;Harmony Ability Package&…
阅读更多...
领域LLM九讲——第4讲 构建可测评、可优化的端到端商业AI Agent 系统

领域LLM九讲——第4讲 构建可测评、可优化的端到端商业AI Agent 系统

领域LLM九讲——第4讲 构建可测评、可优化的端到端商业AI Agent 系统 以 OpenAI Cookbook 的《receipt_inspection》示例为基础&#xff0c;探讨如何设计一个可测试、可优化的端到端 AI Agent 系统。整体流程分为三个阶段&#xff1a; (1) 端到端 Agent 构建&#xff08;基线测…
阅读更多...
MySQL体系架构解析（三）：MySQL目录与启动配置全解析

MySQL体系架构解析（三）：MySQL目录与启动配置全解析

MySQL中的目录和文件 bin目录 在 MySQL 的安装目录下有一个特别重要的 bin 目录&#xff0c;这个目录下存放着许多可执行文件。与其他系统的可执行文件类似&#xff0c;这些可执行文件都是与服务器和客户端程序相关的。 启动MySQL服务器程序 在 UNIX 系统中&#xff0c;用…
阅读更多...
Linux线程与进程关系及底层实现

Linux线程与进程关系及底层实现

在操作系统中&#xff0c;线程切换相比进程切换更轻量级的关键原因之一是 缓存&#xff08;Cache&#xff09;的有效性&#xff0c;尤其是对 CPU 缓存&#xff08;如 L1/L2/L3&#xff09;和 TLB&#xff08;Translation Lookaside Buffer&#xff09;的影响。以下从缓存角度详…
阅读更多...
【论文阅读30】Bi-LSTM(2024)

【论文阅读30】Bi-LSTM(2024)

用于精确实时滑坡检测的双向LSTM模型&#xff1a;以印度梅加拉亚邦毛永格里姆为例的研究 IEEE Internet of Things Journal&#xff08;简称 IoT‑J&#xff09;是一份 IEEE 自 2014 年起双月刊发表的国际顶级学术期刊&#xff0c;专注于物联网各领域的研究。 作者&#xff1a…
阅读更多...
Java编程之原型模式

Java编程之原型模式

原型模式的定义 原型模式&#xff08;Prototype Pattern&#xff09;是一种创建型设计模式&#xff0c;通过复制已有对象来创建新对象&#xff0c;而非通过常规的手段的new关键字来实例化。适用于对象创建成本较高或需要动态配置的场景。 例如&#xff0c;在一个游戏开发中&am…
阅读更多...
RAG质量评估

RAG质量评估

当完成了一个RAG系统的开发工作以后&#xff0c;还需要对该系统的性能进行评估。如何对RAG系统的性能进行评估呢&#xff1f;仔细分析RAG系统的产出成果&#xff0c;主要涉及以下几点&#xff1a; &#xff08;1&#xff09;检索器组件 检索的相关文档 context, &#xff08;…
阅读更多...
LLMs基础学习（八）强化学习专题（1）

LLMs基础学习（八）强化学习专题（1）

LLMs基础学习&#xff08;八&#xff09;强化学习专题&#xff08;1&#xff09; 文章目录 LLMs基础学习&#xff08;八&#xff09;强化学习专题&#xff08;1&#xff09;学习资料资源强化学习是什么强化学习一句话精准定义 强化学习与其他学习类型的对比强化学习 vs 监督学习…
阅读更多...
19-Oracle 23 ai Database Sharding-知识准备

19-Oracle 23 ai Database Sharding-知识准备

小伙伴是不是经常遇见大规模集群和数量的时候&#xff0c;业务就提出要对数据进行sharding。 Oracle 和其他数据库&#xff08;如 MySQL、PostgreSQL、MongoDB 等&#xff09; 为什么要进行分片&#xff08;sharding&#xff09;&#xff0c;分片的原因是什么&#xff0c;实现…
阅读更多...
分类与逻辑回归 - 一个完整的guide

分类与逻辑回归 - 一个完整的guide

线性回归和逻辑回归其实比你想象的更相似 &#x1f603; 它们都是所谓的参数模型。让我们先看看什么是参数模型&#xff0c;以及它们与非参数模型的区别。 线性回归 vs 逻辑回归 线性回归&#xff1a;用于回归问题的线性参数模型。逻辑回归&#xff1a;用于分类问题的线性参数…
阅读更多...
英语写作中“每一个”each individual、every individual、every single的用法

英语写作中“每一个”each individual、every individual、every single的用法

一、Individual &#xff1a;个体&#xff0c;相对于团体&#xff0c;例如&#xff1a; Individual competition &#xff08;个人比赛&#xff09;&#xff0c;相对于team competition &#xff08;团体比赛&#xff09; Individual users &#xff08;个人用户&#xff09;…
阅读更多...
由于 z(x,y) 的变化导致的影响（那部分被分给了链式项）

由于 z(x,y) 的变化导致的影响（那部分被分给了链式项）

✅ 本质问题&#xff1a;为什么链式法则中 ∂ F ∂ x \frac{\partial F}{\partial x} ∂x∂F​ 不考虑 z z ( x , y ) zz(x,y) zz(x,y)&#xff1f; &#x1f50d; 一、关键是&#xff1a;偏导数的定义是什么&#xff1f; 我们从最根本的定义开始&#xff1a; ∂ F ( x , y…
阅读更多...
python打卡day44@浙大疏锦行

python打卡day44@浙大疏锦行

知识点回顾&#xff1a; 预训练的概念常见的分类预训练模型图像预训练模型的发展史预训练的策略预训练代码实战&#xff1a;resnet18 作业&#xff1a; 尝试在cifar10对比如下其他的预训练模型&#xff0c;观察差异&#xff0c;尽可能和他人选择的不同尝试通过ctrl进入resnet的…
阅读更多...
十一(3) 类，加深对拷贝构造函数的理解

十一(3) 类，加深对拷贝构造函数的理解

class ClassName { public: // 拷贝构造函数&#xff1a;参数是同类型对象的引用&#xff08;通常为 const 引用&#xff09; ClassName(const ClassName& other) { // 复制 other 的成员变量到当前对象 } }; 参数要求&#xff1a;必须是同类型对象的引用&#xff0…
阅读更多...
网页后端开发（基础1--maven）

网页后端开发（基础1--maven）

maven的作用&#xff1a; Maven是一款管理和构建Java项目的工具。 1.依赖管理&#xff1a; 方便快捷的管理项目依赖的资源&#xff08;jar包&#xff09; 不用手动下载jar包&#xff0c;只需要中maven中引用&#xff0c;maven会查找本地仓库。若本地仓库没有&#xff0c;会直…
阅读更多...
认识电子元器件---高低边驱动

认识电子元器件---高低边驱动

目录 一、基本概念 二、关键参数对比 三、工作原理 &#xff08;1&#xff09;高边驱动 &#xff08;2&#xff09;低边驱动 四、典型的应用场景 五、如何选择 一、基本概念 可以理解成&#xff1a;高低边驱动是MOS/IGBT的一种应用方式 高低边驱动是电路拓扑概念&#…
阅读更多...
JavaScript 标签加载

JavaScript 标签加载

目录 JavaScript 标签加载script 标签的 async 和 defer 属性&#xff0c;分别代表什么&#xff0c;有什么区别1. 普通 script 标签2. async 属性3. defer 属性4. type"module"5. 各种加载方式的对比6. 使用建议 JavaScript 标签加载 script 标签的 async 和 defer …
阅读更多...
C/CPP 结构体、联合体、位段内存计算 指南

C/CPP 结构体、联合体、位段内存计算 指南

C/CPP 结构体、联合体、位段内存计算 指南 在C语言中&#xff0c;结构体、联合体和位段是对数据的高级抽象&#xff0c;它们可以让程序员以更易于理解的方式来操作复杂的数据结构。然而&#xff0c;这些结构在内存中的布局可能并不如它们的语法结构那样直观&#xff0c;特别是当…
阅读更多...
最新文章

Copyright @ 2022~2023