设计模式学习(一)单例模式补充——指令重排

这篇具有很好参考价值的文章主要介绍了设计模式学习(一)单例模式补充——指令重排。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录
  • 前言
  • 指令重排简介
  • 指令重排对单例模式的影响
  • 改进方法
    • std::call_once和std::once_flag
    • std::atomic和内存顺序
    • 局部静态变量
  • 总结
  • 参考文章

前言

在《单例模式学习》中曾提到懒汉式DCLP的单例模式实际也不是线程安全的,这是编译器的指令重排导致的,本文就简单讨论一下指令重排对单例模式的影响,以及对应的解决方法。

指令重排简介

指令重排(Instruction Reordering)是编译器或处理器为了优化程序执行效率而对程序中的指令序列进行重新排序的过程。这种重排可以发生在编译时也可以发生在运行时,目的是为了减少指令的等待时间和提高执行的并行性。

指令重排可能会引入并发程序中的一些问题,特别是在多线程环境中,没有适当同步机制的情况下,可能会导致程序的执行结果不符合预期。

下面介绍指令重排在单例模式中的影响

指令重排对单例模式的影响

首先回顾一下懒汉式DCLP单例模式的代码

class CSingleton
{
public:
    static CSingleton* getInstance();

private:
    CSingleton()
    {
        std::cout<<"创建了一个对象"<<std::endl;
    }
    CSingleton(const CSingleton&) = delete;
    CSingleton& operator=(const CSingleton&) = delete;
    ~CSingleton()
    {
        std::cout<<"销毁了一个对象"<<std::endl;
    }
    static CSingleton* instance;  
    static std::mutex mtx;
};

CSingleton* CSingleton::instance; 
 
CSingleton* CSingleton::getInstance()
{
    mtx.lock();    
    if(nullptr == instance)
    {
        instance = new CSingleton();
    }
    mtx.unlock();    
    return instance;
}

注意这一句:

instance = new CSingleton();    //并非一个原子操作,不是可重入函数

instance的初始化其实做了三个事情:

  • ①内存分配:为CSingleton对象分配一片内存
  • ②对象构造:调用构造函数构造一个CSingleton对象,存入已分配的内存区
  • ③地址绑定:将指针instance指向这片内存区(执行完这步instance才是非 nullptr)

但是由于指令重排,编译器会将顺序改变为:

instance = //步骤三
operator new(sizeof(CSingleton));//步骤一
new(instance)CSingleton;//步骤二

现在考虑以下场景:
1.线程A进入getInstance(),判断instance为空,请求加锁,然后执行步骤一和三组成的语句,之后A被挂起。此时instance为非空指针(指向了一块内存),但instance指向内存里面的CSingleton对象还未被构造出来。
2.线程B进入getInstance(),判断instance非空(因为在A线程中instance已经为非空指针了),直接返回instance。之后用户使用该指针访问CSingleton对象,嘿!您猜怎么着,这个CSingleton对象还没被构造出来呢。

总的来说,只有步骤一和二在三前面执行,DCLP才有效

改进方法

std::call_once和std::once_flag

std::call_once配合std::once_flag确保了instance = new CSingleton()只会被执行一次,无论它被多少个线程访问。这避免了指令重排在多线程下导致的问题。

class CSingleton
{
private:
	...
public:
    static CSingleton* getInstance();   
private:
    static CSingleton* instance;
    static std::once_flag onceFlag;
}

CSingleton* CSingleton::instance;

std::once_flag CSingleton::onceFlag;

CSingleton* CSingleton::getInstance()
{
	    /*
	    call_once和once_flag保证了多线程下仅有一个线程可以执行该函数,因此无需手动加锁
	    而且当 std::call_once 被多次调用时(无论是由同一个线程还是不同的线程)
	    只有第一次调用会执行传递给它的函数
	    所有随后的调用,都不会再次执行该函数
	    */
	    std::call_once(onceFlag,[](){instance = new CSingleton();});
        return instance;
}

std::atomic和内存顺序

class CSingleton
{
private:
	...
public:
    static CSingleton* getInstance()
    
private:
    static std::atomic<CSingleton*> instance;
    static std::mutex mtx;
}

std::atomic<CSingleton*> CSingleton::instance;

std::mutex CSingleton::mtx;

CSingleton* CSingleton::getInstance()
{
    //核心框架还是双检查
	//保证了这个读操作之后发生的读写操作不会被重排到这个操作之前
    CSingleton* tmp = instance.load(std::memory_order_acquire);
    if (nullptr == tmp) 
    {
           std::lock_guard<std::mutex> lock(mtx);
           //再次获取,检查是否有其他线程在获取锁的过程中创建了实例
           tmp = instance.load(std::memory_order_relaxed);
           if (nullptr == tmp) 
           {
               tmp = new CSingleton();
               //保证了在这个写操作之前的所有操作都不会被重排到这个操作之后
               //确保了实例完全构造好之后,其他线程通过 `instance` 读取到的值是最新的
               instance.store(tmp, std::memory_order_release);
           }
    }
       return tmp;
}

局部静态变量

最后,害得是局部静态变量形式的单例模式,大道至简!

static CSingleton& getInstance() 
{
    static CSingleton instance;
    return instance;
}

具体原因见:《单例模式学习》

总结

本文讨论了指令重排对多线程下的单例模式的影响,并例举了几个解决方案。后面可能还会更新别的解决方案

参考文章

1.C++ and the Perils of Double-Checked Locking
2.Double-Checked Locking is Fixed In C++11文章来源地址https://www.toymoban.com/news/detail-841326.html

到了这里,关于设计模式学习(一)单例模式补充——指令重排的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 设计模式学习(一)单例模式的几种实现方式

    目录 前言 饿汉式 懒汉式 懒汉式DCLP 局部静态式(Meyers\\\' Singleton) 单例模板 参考文章 单例模式,其核心目标是确保在程序运行的过程中,有且只有存在一个实例才能保证他们的逻辑正确性以及良好的效率。因此单例模式的实现思路就是确保一个类有且只有一个实例,并提供

    2024年03月19日
    浏览(44)
  • 懒汉单例设计模式与饿汉单例设计模式

    单例模式即一个类确保只有一个对象,主要用于避免浪费内存 1 .饿汉单例设计模式 :拿到对象时,对象就早已经创建好了 写法: 把类的构造器私有 在类中自己创建一个对象,并赋值到一个变量 定义一个静态方法,返回自己创建的这个对象 2. 懒汉单例设计模式 :第一次拿到对象时

    2024年02月21日
    浏览(59)
  • 【设计模式】单例设计模式

    目录 1、前言 2、基本语法 2.1、懒汉式单例 2.2、饿汉式单例 2.3、双重检验锁单例模式 2.4、静态内部类单例模式 2.5、枚举单例模式 2.6、ThreadLocal单例模式 2.7、注册单例模式 3、使用场景 4、使用示例 5、常见问题 5、总结 单例模式是一种设计模式,它确保一个类只能创建一个实

    2024年02月09日
    浏览(44)
  • 【常用设计模式】待补充

    Github仓库地址 23中设计模型分为常见的三大类:创建型模式、结构型模式和行为型模式 描述 简单工厂模式不是23中设计模式中的。简单工厂模式不直接向客户端暴露对象创建的细节,而是通过一个工厂类来负责创建产品类的实例 角色 抽象产品角色:给具体产品角色提供接口

    2024年02月08日
    浏览(47)
  • 【设计模式】单例模式|最常用的设计模式

    单例模式是最常用的设计模式之一,虽然简单,但是还是有一些小坑点需要注意。本文介绍单例模式并使用go语言实现一遍单例模式。 单例模式保证一个类仅有一个实例,并提供一个访问它的全局访问点。 使用场景: 当类只能有一个实例而且可以从一个公开的众所周知的访

    2024年04月29日
    浏览(42)
  • 设计模式之单例设计模式

    就是一个类只允许创建一个对象,那么我们称该类为单例类,这种设计模式我们称为单例模式。 资源共享:有些类拥有共享的资源,例如数据库连接池、线程池、缓存等。使用单例模式确保只有一个实例,避免资源浪费和竞争条件。 线程安全:单例模式可以用来保证多线程

    2024年02月07日
    浏览(75)
  • 设计模式(单例模式)

            保证指定的类只有一个实例,不能创建出其他的实例                 1.1 代码展示                 1.2 Singleton类中instance对象的创建时机                 Singleton类中instance对象的创建时机:在Singleton类被jvm加载的时候创建,Singleton类会在第一次使用的时

    2024年02月15日
    浏览(51)
  • 设计模式-单例模式

          单例模式(Singleton Pattern)是设计模式中最简单且最常用的一种创建型模式,其目的是保证一个类在整个系统中只存在一个实例,并提供全局访问点来获取这个唯一实例。这种模式主要适用于那些需要频繁实例化然后又希望避免因为多次实例化而消耗过多资源或产生副

    2024年01月17日
    浏览(53)
  • 设计模式 ~ 单例模式

    单例模式:指在确保一个类只有一个实例,创建之后缓存以便继续使用,并提供一个全局访问点来访问该实例; 前端对于单例模式不常用,但对于单例的思想无处不在; 如:弹窗、遮罩层、登录框、vuex redux 中的 store; 闭包: 模块化:

    2024年02月16日
    浏览(57)
  • 【设计模式-单例模式】

    在一个项目中的全局范围内, 一个类 有且仅有一个实例对象 。这个唯一的实例对象给其他模块提供数据的 全局访问 。这样的模式就叫 单例模式 。 单例模式的典型例子就是任务队列。 首先, 考虑单例模式的要求为有且仅有一个实例对象。那么就先从构造函数入手。类的构

    2024年02月13日
    浏览(60)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包