单例模式和读者写者问题

news2024/11/25 5:00:29

文章目录

  • 10. 线程安全的单例模式
    • 10.1 什么是设计模式
    • 10.2 什么是单例模式
    • 10.3 单例模式的特点
    • 10.4 饿汉方式和懒汉方式
    • 10.5 单例模式的线程池
  • 11. STL和智能指针的线程安全 问题
    • 11.1 STL中的容器是否是线程安全的?
    • 11.2 智能指针是否是线程安全的?
  • 12. 其他常见的各种锁
  • 13. 读者写者问题
    • 13.1 概念
    • 13.2 读写锁接口
    • 13.3 读者优先的伪代码

10. 线程安全的单例模式

10.1 什么是设计模式

设计模式（Design Pattern）是软件工程中的一种最佳实践，它是在特定场景下解决特定问题的成熟模板或方案。设计模式是面向对象软件开发过程中经过验证的经验和智慧的结晶，它们提供了一种通用的、可复用的解决方案来解决在软件设计中遇到的常见问题。

10.2 什么是单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，其核心目的是确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。这种模式在需要控制资源访问、节省系统资源、协调系统中的共享资源时非常有用。

10.3 单例模式的特点

单例模式的主要特点包括：

  1. 唯一性：确保一个类只有一个实例。
  2. 全局访问：提供一个全局访问点来获取这个唯一的实例。

10.4 饿汉方式和懒汉方式

饿汉方式（Eager Initialization）

饿汉方式是指在程序启动时就立即创建单例对象。这种方式的优点是简单、线程安全，因为对象的创建是在程序启动时完成的，不存在多线程同时访问的问题。缺点是如果单例对象的创建比较耗时或者占用资源较多，可能会影响程序的启动速度。

懒汉方式的单例模式实现如下：

class Singleton 
{
public:
    static Singleton& getInstance() 
    {
        return instance;
    }
private:
    static Singleton instance; // 静态成员变量，饿汉式，直接在类中创建实例
    Singleton() {} // 私有构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值操作
};

// 在类外初始化静态成员变量
Singleton Singleton::instance;

懒汉方式（Lazy Initialization）

懒汉方式是指在第一次使用单例对象时才创建它。这种方式的优点是可以延迟对象的创建，从而加快程序的启动速度，并且只有在真正需要时才创建对象。缺点是如果多个线程同时访问单例对象，可能会存在线程安全问题，所以要加锁。

线程不安全的懒汉方式实现的单例模式

class Singleton 
{
public:
    static Singleton* getInstance() 
    {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
private:
    static Singleton* instance; // 静态成员变量指针，懒汉式，延迟创建实例
    Singleton() {} // 私有构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值操作
};

// 在类外初始化静态成员变量指针
Singleton* Singleton::instance = nullptr;

使用局部静态变量来实现线程安全的懒汉式单例，因为局部静态变量的初始化在C++ 11中是线程安全的。

class Singleton 
{
public:
    static Singleton& getInstance() {
        static Singleton instance; // 局部静态变量，线程安全的懒汉式
        return instance;
    }
private:
    Singleton() {} // 私有构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值操作
};

getInstance方法中的局部静态变量instance只会在第一次调用getInstance时被创建，之后的调用都会返回同一个实例，这种方式既实现了懒汉式的延迟加载，又保证了线程安全。

使用加锁的方式

class Singleton 
{
public:
    static Singleton* getInstance() 
    {
        if (instance == nullptr) {		// 双重判定空指针, 降低锁冲突的概率, 提高性能.
            pthread_mutex_lock(&mutex);	// 使用互斥锁, 保证多线程情况下也只调用一次 new.
            if (instance == nullptr) 
            	instance = new Singleton();
           	pthread_mutex_unlock(&mutex);
        }
        return instance;
    }
private:
    static Singleton* instance; // 静态成员变量指针，懒汉式，延迟创建实例
    static pthread_mutex_t mutex;		// 锁
    Singleton() {} // 私有构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值操作
};

// 在类外初始化静态成员变量指针
Singleton* Singleton::instance = nullptr;
pthread_mutex_t Singleton::mutex = PTHREAD_MUTEX_INITIALIZER;

10.5 单例模式的线程池

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <semaphore.h>
#include <pthread.h>
#include <vector>
#include <queue>
using namespace std;
struct ThreadData
{
    pthread_t tid;
    string name;
};

// T表示任务的类型
template<class T>
class ThreadPool
{
public:
	// ...
    static ThreadPool* GetInstance()
    {   
        if(tp == nullptr) {
            pthread_mutex_lock(&lock);
            if(tp == nullptr) 
                tp = new ThreadPool<T>();
            pthread_mutex_unlock(&lock);
        }
        return tp;
    }
private:
    ThreadPool(size_t num = defaultNum) : _threads(num) 
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);
    }

    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
    }

    ThreadPool(const ThreadPool& tp) = delete;
    const ThreadPool operator=(const ThreadPool& tp) = delete;

    vector<ThreadData> _threads;
    queue<T> _tasks;    // 任务，这是临界资源
    pthread_mutex_t _mutex;
    pthread_cond_t _cond;

    static ThreadPool* tp;
    static pthread_mutex_t lock;
};
template<class T>
ThreadPool<T>* ThreadPool<T>::tp = nullptr;
template<class T>
pthread_mutex_t ThreadPool<T>::lock = PTHREAD_MUTEX_INITIALIZER;

11. STL和智能指针的线程安全 问题

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

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

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

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

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

12. 其他常见的各种锁

  • 悲观锁（Pessimistic Locking）：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。
  • 乐观锁（Optimistic Locking）：每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式：版本号机制和CAS操作。
    • CAS操作：当需要更新数据时，判断当前内存值和之前取得的值是否相等。如果相等则用新值更新。若不等则失败，失败则重试，一般是一个自旋的过程，即不断重试。
  • 自旋锁（Spinlock）：当一个线程尝试获取一个已经被其他线程持有的锁时，该线程不会立即进入等待状态（即不会释放CPU），而是在原地“自旋”，也就是不停地进行忙等待（busy-waiting），直到获取到锁。
    • 当一个线程尝试获取一个已经被占用的自旋锁时，它会在原地循环检查锁的状态，直到锁变为可用。
    • 自旋锁不会使线程进入睡眠状态，因此它是一种非阻塞的同步机制。
    • 由于线程不会进入睡眠状态，自旋锁避免了线程上下文切换的开销。
    • 由于自旋锁会导致CPU资源的占用，因此它更适合于那些预计会很快释放的锁。如果锁的持有时间较长，自旋锁可能会导致CPU资源的浪费。
    • 如果持有自旋锁的线程发生阻塞，那么等待该锁的线程可能会无限期地自旋下去，导致死锁。
    • 之前使用的都属于悲观锁，是否采用自旋锁取决于线程在临界资源会待多长时间。
  • 公平锁（Fair Lock）是一种锁机制，它确保了线程获取锁的顺序与它们请求锁的顺序相同。换句话说，公平锁保证了“先来先服务”（FIFO，First-In-First-Out）的原则，即最先请求锁的线程将最先获得该锁。
  • 非公平锁（Non-Fair Lock）是一种锁机制，它不保证线程获取锁的顺序与它们请求锁的顺序相同。这意味着当一个线程尝试获取一个非公平锁时，它可能会与已经等待该锁的其他线程竞争，而不管这些线程等待了多久。

13. 读者写者问题

13.1 概念

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

image-20241011150938421

  • 3种关系：
    • 写者 vs 写者 （互斥）
    • 读者 vs 写者 （互斥，同步）
    • 读者 vs 读者 （共享关系）这是和生产消费者模型的区别
  • 2个角色：读者和写者
  • 1个交易场所：数据交换的地点

为什么读者写者问题中读者和读者关系是共享 而生产消费者模型中 消费者和消费者的关系是互斥呢？

因为读者并不会对数据做处理，只是对数据进行读操作。而消费者会对数据进行数据处理。

一般来说，读者多，写者少。所以概率上讲读者更容易竞争到锁，写者可能会出现饥饿问题。
这是读者写者问题的特点。也可以更改这个现象，设置同步策略，让写者优先

  • 读者优先：在这种策略下，如果读者和写者同时等待访问临界区，读者会被优先允许进入。这种策略可以减少写者的等待时间，因为读者通常持有锁的时间较短。然而，如果读者持续不断地访问数据，写者可能会遭遇饥饿，即长时间无法获得对数据的访问权。
  • 写者优先：：在这种策略下，如果读者和写者同时等待访问临界区，写者会被优先允许进入。这种策略可以防止读者饥饿，因为写者一旦获得访问权，会阻止新的读者进入，直到写者完成写操作。但是，如果写者频繁地访问数据，读者可能会遭遇饥饿。

13.2 读写锁接口

// 初始化
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t* restrict attr);

// 销毁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

// 加锁和解锁
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

13.3 读者优先的伪代码

int reader_count = 0;
mutex_t rlock, wlock;

// 读者加锁 && 解锁
lock(&rlock);
read_count++;
if(reader_count==1)	lock(&wlock);
unlock(&rlock);
// 读者进行读取
lock(&rlock);
reader_count--;
if(reader_count==0)	unlock(&wlock);
unlock(rlock);

// 写者加锁 && 解锁
lock(&wlock);
// 写者进行写入操作
unlock(&wlock)
  1. 读者加锁：
    • 首先，读者尝试获取 rlock 锁，以安全地修改 reader_count 变量。
    • 获取 rlock 后，读者增加 reader_count 的值。
    • 如果这是第一个进入的读者（即 reader_count 从0变为1），则需要获取 wlock 锁，以阻止写者写入数据。这是因为一旦有读者在读取数据，写者就不应该修改数据，否则会影响读者读取的一致性。（读者优先！）
    • 完成 reader_count 的增加和可能的 wlock 获取后，读者释放 rlock 锁。
  2. 读者解锁：
    • 读者完成读取操作后，再次获取 rlock 锁，以便安全地减少 reader_count 的值。
    • 如果这是最后一个离开的读者（即 reader_count 从1变为0），则需要释放 wlock 锁，允许写者进行写入操作。
    • 完成 reader_count 的减少和可能的 wlock 释放后，读者释放 rlock 锁。
  3. 写者加锁：
    • 写者尝试获取 wlock 锁，以独占访问权进行写入操作。
    • 一旦获取 wlock 锁，写者可以安全地进行写入操作，因为此时没有读者在读取数据。
  4. 写者解锁：
    • 写者完成写入操作后，释放 wlock 锁，允许其他读者或写者访问数据。

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

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

相关文章

【Linux】来查看当前系统的架构

【Linux】来查看当前系统的架构

使用 uname 命令 uname -m 使用 arch 命令 arch 查看 /proc/cpuinfo 文件 查找 model name 或 Processor 字段。 cat /proc/cpuinfo 使用 lscpu 命令 lscpu
阅读更多...
linux线程 | 线程的控制

linux线程 | 线程的控制

前言&#xff1a;本节内容为线程的控制。在本篇文章中&#xff0c; 博主不仅将会带友友们认识接口&#xff0c; 使用接口。 而且也会剖析底层&#xff0c;带领友友们理解线程的底层原理。 相信友友们学完本节内容&#xff0c; 一定会对线程的控制有一个很好的把握。 那么&#…
阅读更多...
算法：反转链表

算法：反转链表

一、题目描述 给定单链表的头节点 head &#xff0c;请反转链表&#xff0c;并返回反转后的链表的头节点。 二、解题思路 1.迭代法 原始链表中&#xff0c;每个结点的 next 指针都指向后一个结点。反转链表之后&#xff0c;每个结点的 next 指针都指向前一个结点。因此&…
阅读更多...
Unity UndoRedo（撤销重做）功能

Unity UndoRedo（撤销重做）功能

需求 撤销与重做功能 思考 关于记录的数据的两点思考&#xff1a; 记录操作记录影响显示和逻辑的所有数据 很显然这里就要考虑取舍了&#xff1a; 记录操作 这种方案只需要记录每一步的操作&#xff0c;具体这个操作要怎么渲染和实现出来完全需要自己去实现&#xff0c;这…
阅读更多...
怎么下载安装yarn

怎么下载安装yarn

安装 npm install --global yarn 是否安装成功 yarn -v Yarn 淘宝源安装&#xff0c;分别复制粘贴以下代码行到黑窗口运行即可 yarn config set registry https://registry.npm.taobao.org -g yarn config set sass_binary_site http://cdn.npm.taobao.org/di…
阅读更多...
免杀对抗—python分离免杀无文件落地图片隐写SOCK管道

免杀对抗—python分离免杀无文件落地图片隐写SOCK管道

前言 之前就基本把所有语言都讲了一遍了&#xff0c;C/C&#xff0c;Java&#xff0c;python&#xff0c;golang&#xff0c;汇编。今天就开始讲免杀的技巧以及手法&#xff0c;分离免杀之前讲过一点&#xff0c;就是通过http或者参数获取shellcode&#xff0c;今天把其他的分…
阅读更多...
ppt压缩文件怎么压缩？压缩PPT文件的多种压缩方法

ppt压缩文件怎么压缩？压缩PPT文件的多种压缩方法

ppt压缩文件怎么压缩&#xff1f;当文件体积过大时&#xff0c;分享和传输就会变得困难。许多电子邮件服务对附件的大小有限制&#xff0c;而在网络环境不佳时&#xff0c;上传和下载大文件可能耗时较长。此外&#xff0c;在不同设备上播放时&#xff0c;较大的PPT文件还可能导…
阅读更多...
Chromium HTML attribute与c++接口对应关系分析

Chromium HTML attribute与c++接口对应关系分析

<a href"https://www.w3school.com.cn" target"_blank">访问 W3School</a>前端这些属性定义在html_attribute_names.json5文件中&#xff1a; third_party\blink\renderer\core\html\html_attribute_names.json5 html_attribute_names.json5…
阅读更多...
【前端碎片记录】大文件分片上传

【前端碎片记录】大文件分片上传

大文件分片上传&#xff0c;主要是为了提高上传效率&#xff0c;避免网络问题或者其他原因导致整个上传失败。 HTML部分没什么特殊代码&#xff0c;这里只写js代码。用原生js实现&#xff0c;框架中可参考实现 // 获取上传文件的 input框 const ipt document.querySelector(…
阅读更多...
Richtek立锜科技线性稳压器 (LDO) 选型

Richtek立锜科技线性稳压器 (LDO) 选型

一、什么是LDO? LDO也可称为低压差线性稳压器&#xff0c;适合从较高的输入电压转换成较低输出电压的应用&#xff0c;这种应用的功率消耗通常不是很大&#xff0c;尤其适用于要求低杂讯、低电流和输入、输出电压差很小的应用环境。 二、LDO的特性 LDO透过控制线性区调整管…
阅读更多...
【每日一坑】pcb出的光绘文件导入到cam350有两个警告

【每日一坑】pcb出的光绘文件导入到cam350有两个警告

pcb出的光绘文件导入到cam350有两个警告&#xff1a; 1 Warning - Zero radius arc detected. Assuming linear interpolation. 2 Warning - Apertures are used which have a size of 0. 这个 应该检查到处光绘文件时候&#xff0c;默认的线宽是否为0&#xff1b; 通过负片…
阅读更多...
面试八股文对校招的用处有多大？C/C++语言篇

面试八股文对校招的用处有多大？C/C++语言篇

前言 1.本系列面试八股文的题目及答案均来自于网络平台的内容整理&#xff0c;对其进行了归类整理&#xff0c;在格式和内容上或许会存在一定错误&#xff0c;大家自行理解。内容涵盖部分若有侵权部分&#xff0c;请后台联系&#xff0c;及时删除。 2.本系列发布内容分为12篇…
阅读更多...
单通道 LVDS 差分线路接收器MS21112S

单通道 LVDS 差分线路接收器MS21112S

MS21112S 是一款单通道低压差分信号 (LVDS) 线 路接收器。在输入共模电压范围内&#xff0c;差分接收器可以 将 100mV 的差分输入电压转换成有效的逻辑输出。 该芯片可应用于 100Ω 的受控阻抗介质上&#xff0c;进行点对 点基带数据传输。传输介质可以是印刷电路板、…
阅读更多...
图像处理（二）——MDPI特刊推荐

图像处理（二）——MDPI特刊推荐

特刊征稿 01 期刊名称&#xff1a; Computer Vision and Image Processing, 2nd Edition 截止时间&#xff1a; 投稿截止日期&#xff1a;2024年12月31日 目标及范围&#xff1a; 感兴趣的主题包括但不限于&#xff1a; 用于图像分类和识别的深度学习 对象检测和跟…
阅读更多...
EdgeNAT: 高效边缘检测的 Transformer

EdgeNAT: 高效边缘检测的 Transformer

EdgeNAT: Transformer for Efficient Edge Detection 介绍了一种名为EdgeNAT的基于Transformer的边缘检测方法。 1. 背景与动机 EdgeNAT预测结果示例。(a, b)：来自BSDS500的数据集的输入图像。(c, d)：对应的真实标签。(e, f)：由EdgeNAT检测到的边缘。(e)显示了由于颜色变化…
阅读更多...
QT元对象系统特性详细介绍（信号槽、类型信息、动态设置属性）（注释）

QT元对象系统特性详细介绍（信号槽、类型信息、动态设置属性）（注释）

目 录 一、元对象系统简介 二、信号和槽 三、类型信息 四、动态设置属性 一、元对象系统简介 QT中的元对象系统Q_OBJECT并不是C标准代码&#xff0c;因此在使用时需要QT的MOC&#xff08;元对象编译器&#xff09;进行预处理&#xff0c;MOC会在编译时期读取C代码中的特定…
阅读更多...
暗语源码 复现佛禅翻译系统v2升级版源码

暗语源码 复现佛禅翻译系统v2升级版源码

与佛论禅翻译系统 一个翻译佛论的娱乐系统&#xff0c;类似于核心价值观加密 此为升级版&#xff0c;每次加密得到的结果不一样&#xff0c;配合箴言功能&#xff0c;更加安全 源码下载&#xff1a;https://download.csdn.net/download/m0_66047725/89874751 更多资源下载&a…
阅读更多...
现代易货交易：重塑价值，引领未来交易新风尚

现代易货交易：重塑价值，引领未来交易新风尚

在当今经济蓬勃发展的背景下&#xff0c;一种新颖的交易模式——现代易货交易&#xff0c;正逐渐崭露头角并赢得市场的认可。这一模式不仅对传统物品交换方式进行了革新&#xff0c;更在物品价值的评估与交换手段上展现出创新性。那么&#xff0c;现代易货交易究竟是何方神圣&a…
阅读更多...
基于SSM的旅游网站【附源码】

基于SSM的旅游网站【附源码】

基于SSM的旅游网站&#xff08;源码L文说明文档&#xff09; 目录 4 系统设计 4.1 系统概要设计 4.2 系统功能结构设计 4.3 数据库设计 4.3.1 数据库E-R图设计 4.3.2 数据库表结构设计 5 系统实现 5.1 管理员功能介绍 5.1.1 用户管理 5.1.2 …
阅读更多...
比较模拟数据

比较模拟数据

模拟数据检查器可以比较来自工作区、文件或模拟中的运行和单个信号的数据和元数据。可以使用公差来分析比较结果&#xff0c;并可以通过指定信号属性和比较约束来配置比较行为。此示例使用从模型slexAircraftExample的模拟中记录的数据&#xff0c;演示了以下内容&#xff1a; …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023