C++单例模式与线程安全

已于 2022-03-05 17:38:00 修改
阅读量1.9k 收藏 12
点赞数 5
分类专栏： 编程语言 设计模式 文章标签： 抽象代数 数论 自然语言处理 c++
于 2022-03-05 17:34:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27576655/article/details/123298194
版权

C++单例模式与线程安全

最简单的单例模式可以是

// single thread safe version
class Singleton {
    public:
        static Singleton* GetInstance(int x = 0) {
            if (instance_ == NULL) {
                instance_ = new Singleton(x);
            }
            return instance_;
        }
        void Print() {
            std::cout << this->member_ << std::endl;
        }
    private:
        Singleton(int x = 3) : member_(x) {}
        int member_;
        static Singleton* instance_;  //declare a static member variable
};

Singleton* Singleton::instance_ = NULL;  //define a static member variable

然而，在多线程情况下，比如线程A 判断instance_ 为空后，此时线程A暂停执行挂起，而线程B 判断 instance_ 也为空，于是会调用构造函数创建对象，并返回，而线程A继续恢复运行后，同样会调用构造函数创建对象，并修改 instance_ 指针。导致第一个指针被修改，引发线程安全问题。

基于此，可以在判断 instance_ 为空前，先加锁，拿到锁的线程才能进一步判断 instance_ 是否为空，并进一步决定是否创建该对象。代码如下

// thread safe, but inefficiency
class Singleton {
    public :
        static Singleton* GetInstance(int x = 0) {
            std::lock_guard<std::mutex> lock(mtx);
            if (instance_ == NULL) {
                instance_ = new Singleton(x);
            }
            return instance_;
        }
        void Print() {
            std::cout << this->member_ << std::endl;
        }

    private:
        Singleton(int x = 3) : member_(x) {}
        int member_;
        static Singleton* instance_;  //declare a static member variable    
};

Singleton* Singleton::instance_ = NULL;  //define a static member variable

然而，此方法存在效率问题，每次调用 GetInstance()获取该对象指针时，都需要加锁。显然，我们只是希望在首次创建对象的时候才需要加锁，后续的访问不用再加锁(已经创建好了对象)，于是很自然的想到在加锁前，再进行一次判断 instance_ 是否为空，代码如下

// double-checked locking
class Singleton {
    public :
        static Singleton* GetInstance(int x = 0) {
            if (instance_ == NULL) {
                std::lock_guard<std::mutex> lock(mtx);
                if (instance_ == NULL) {
                    instance_ = new Singleton(x);
                    /*
                    instance_ =       //  point to memory
                        operator new(sizeof(Singleton));  // memory allocate
                    new (instance_) Singleton;  //  construct a object int the allocated memory, may occur exception
                    */
                }
            }
            return instance_b_;
        }
        void Print() { 
            std::cout << this->member_ << std::endl;
        }

    private:
        Singleton(int x = 3) : member_(x) {}
        int member_;
        static Singleton* instance_;  //declare a static member variable    
};

Singleton* Singleton::instance_ = NULL;  //define a static member variable

上述方法很好的解决了频繁加锁带来的开销，但是仍然存在一些问题，对于 new 调用，其过程为

  1. 从堆区分配内存
  2. 在分配的内存执行构造函数
  3. 返回其指针

而实际上，经过编译器优化后的代码执行顺序可能并不是这样的，比如

instance_ = new Singleton(x);

可能等价于

instance_ = operator new(sizeof(Singleton));  // memory allocate
new (instance_) Singleton;  // placement new

即

  1. 从堆区分配内存
  2. 返回堆区的指针
  3. 对指针指向的内存执行构造函数

该情形下，如果线程A在执行到 instance_ = operator new(sizeof(Singleton)); 后，暂停运行挂起，线程B在进入GetInstance() 并判断 instance_ 是否为空时，发现其不为空，于是返回 instance_ 指针，然而该指针是没有经过初始化的，所以线程B对该指针的使用将可能会引起未定义的行为。为了防止发生编译器的优化后的代码执行顺序和我们预期的不一致(上述2，3步调换了顺序)，我们希望确保在 new 调用构造函数成功后，再修改 instance_ 指针，代码如下

// in-case exception occur when construct
class Singleton {
    public :
        static Singleton* GetInstance(int x = 0) {
            if (instance_ == NULL) {
                std::lock_guard<std::mutex> lock(mtx);
                if (instance_ == NULL) {
                    Singleton* temp = new Singleton(x);
                    instance_ = temp;
                }
            }
            return instance_;
        }
        void Print() { 
            std::cout << this->member_ << std::endl;
        }

    private:
        Singleton(int x = 3) : member_(x) {}
        int member_;
        static Singleton* instance_;  //declare a static member variable    
};

Singleton* Singleton::instance_ = NULL;  //define a static member variable

这里我们引入了 temp 指针，用于确保 new 调用成功后，再去修改 instance_ 指针，对new 进行替换后如下

// in-case exception occur when construct
class Singleton {
    public :
        static Singleton* GetInstance(int x = 0) {
            if (instance_ == NULL) {
                std::lock_guard<std::mutex> lock(mtx);
                if (instance_ == NULL) {
                    Singleton* temp = operator new(sizeof(Singleton));  // memory allocate
										new (temp) Singleton;  // placement new
                    instance_ = temp;
                }
            }
            return instance_;
        }
        void Print() { 
            std::cout << this->member_ << std::endl;
        }

    private:
        Singleton(int x = 3) : member_(x) {}
        int member_;
        static Singleton* instance_;  //declare a static member variable    
};

Singleton* Singleton::instance_ = NULL;  //define a static member variable

然而，对于上述代码，编译器仍可能对进行优化，编译器会发现temp 变量在程序中只是起到一个传递值的作用，可以被优化掉，优化后的代码将直接是 instance_ = new Singleton(x); ，为了防止编译器出现此类优化，我们可以进一步使用 volatile 关键字来防止编译器的优化，代码如下

class Singleton {
    public :
        static Singleton* GetInstance(int x = 0) {
            if (instance_ == NULL) {
                std::lock_guard<std::mutex> lock(mtx);
                if (instance_ == NULL) {
                    Singleton* volatile temp = new Singleton(x);
                    instance_ = temp;
                }
            }
            return instance_;
        }
        void Print() { 
            std::cout << this->member_ << std::endl;
        }

    private:
        Singleton(int x = 3) : member_(x) {}
        int member_;
        static Singleton* instance_;  //declare a static member variable    
};

Singleton* Singleton::instance_ = NULL;  //define a static member variable

上述代码对temp 变量声明为 volatile，其目的在于告诉编译器，temp相关的代码块不能进行优化，temp相关的指令序列和高级语言看到的应该完全一致。

然而，这里还是可能存在问题，volatile只保证了对temp变量的相关代码的操作顺序，而对temp的成员没有保证，比如下述代码

// in-case exception occur when construct
class Singleton {
    public :
        static Singleton* GetInstance(int x = 0) {
            if (instance_ == NULL) {
                std::lock_guard<std::mutex> lock(mtx);
                if (instance_ == NULL) {
                    Singleton* temp = operator new(sizeof(Singleton));  // memory allocate
										temp->member_ = x;  // construct
                    instance_ = temp;
                }
            }
            return instance_;
        }
        void Print() { 
            std::cout << this->member_ << std::endl;
        }

    private:
        Singleton(int x = 3) : member_(x) {}
        int member_;
        static Singleton* instance_;  //declare a static member variable    
};

Singleton* Singleton::instance_ = NULL;  //define a static member variable

temp的构造函数在对temp 的成员变量进行赋值时 temp->member_ = x，该操作和 instance_ = temp 可能会因为编译器的优化而重排顺序，如果 instance_ = temp 先于temp->member_ = x 执行

instance_ = temp;
temp->member_ = x

当线程A 在执行完 instance_ = temp; 后暂时挂起，线程B获取到 instance_ 后访问其成员变量 member_时，将会引发未定义的行为(如果是指针，将会发生core)，因此我们需要保证 类Singleton 的所有成员变量的相关操作应该也是 volatile 的，于是代码如下

class Singleton {
    public :
        static volatile Singleton* GetInstance(int x = 0) {
            if (instance_ == NULL) {
                std::lock_guard<std::mutex> lock(mtx);
                if (instance_ == NULL) {
                    volatile Singleton* temp = new volatile Singleton(x);
                    instance_ = temp;
                }
            }
            return instance_;
        }
        void Print() { 
            std::cout << this->member_ << std::endl;
        }

    private:
        Singleton(int x = 3) : member_(x) {}
        int member_;
        static volatile Singleton* instance_;  //declare a static member variable    
};

volatile Singleton* Singleton::instance_ = NULL;  //define a static member variable

参考链接:https://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf

Deep_Blue7
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ 实现一个线程安全的单例模式
mcc12356的博客
06-19 383
首先简单介绍一下单例模式。顾名思义，单例模式就是一个类只允许建一个对象，在实际工程中经常会用到。比如一些配置文件的类，多个对象没有意义且浪费资源，所以这时候就可以使用单例模式去实现。 C++实现单例模式最简单的方法就是让一个类构造函数私有化，并且内部提供一个公有接口，每当有需要获取这个类的对象的时候就调用此公有接口，返回这个类的对象。 代码如下： class Singleton { private: Singleton(){} private: // 此类唯一对象
C++ 线程安全的单例模式总结
s11show_163的博客
01-21 850
1. 什么是线程安全？ 在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。 2. 如何保证线程安全？ 给共享的资源加把锁，保证每个资源变量每时每刻至多被一个线程占用。 让线程也拥有资源，不用去共享进程中的资源。如： 使用threadlocal可以为每个线程的维护一个私有的本地变量。 3. 什么是单例模式？ 单例模式指在整个系统生命周期里，保证一个类只能产生一个实例，确保该类的唯一性。 3.1. 单例模式分类 单例模式可以分为
C++两种线程安全的单例模式的实现
07-05
使用"懒汉模式"与"饿汉模式"实现c++的单例模式，并且确保了单例模式的第一次实例化的线程安全，以及程序结束时，单例对象的资源收回，以防内存资源的泄漏
C++单例模式--线程安全
u013967450的博客
07-27 2743
　前段时间使用c++做项目开发，需要根据根据配置文件路径加载全局配置文件，并对外提供唯一访问点。面对这样一个需求，自然的就想到了使用单例模式来创建一个单例配置对象，供外部调用。一开始想使用boost中自带的单例类来实现，但是遗憾的是，boost中的的单例类好像只能使用无参的类构造函数，而我希望将配置文件路径作为单例配置对象的构造函数参数，此外正好借此机会使用c++自己动手实现一个单例类。 　　1.线程安全的c++单例类 　　　实现线程安全的c++单例类，主要要实现以下几点：1）构造函数私有化，即构造函数
C++实现线程安全的单例模式
AI吃大瓜的博客
08-24 7937
C++实现线程安全的单例模式 1、单例模式 　　一个简单的单例模式很容易实现：构造函数声明为private或protect防止被外部函数实例化，内部保存一个private static的类指针保存唯一的实例，实例的动作由一个public的类方法代劳，该方法也返回单例类唯一的实例。 class singleton { protected: singleton(){} private:...
C++单例模式与多线程安全
PPprogrammer的博客
01-23 1903
用代码实现如下： class Singleton { public: static Singleton* CreateObj() { if (m_pInstance == NULL) { m_pInstance = new Singleton(); } return m_pInstance; } void test() { cout << "访问单例类的接...
从C++单例模式到线程安全详解
08-31
总的来说，实现线程安全的C++单例模式需要注意多线程环境下的并发问题，避免指令重排序和编译器优化带来的隐患。使用C++11提供的工具如`std::call_once`可以简化这一过程，确保在多线程环境中正确地实现单例模式。
老生常谈C++的单例模式与线程安全单例模式(懒汉/饿汉)
12-25
1 教科书里的单例模式 我们都很清楚一个简单的单例模式该怎样去实现：构造函数声明为private或protect防止被外部函数实例化，内部保存一个private static的类指针保存唯一的实例，实例的动作由一个public的类方法...
使用C++11实现线程安全的单例模式
04-05
C++11引入了新的特性，如std::mutex和std::call_once，使得实现线程安全的单例模式变得更加容易和高效。 首先，我们需要理解C++11中的线程模型。在C++11之前，C++标准并不直接支持多线程编程。C++11引入了 `...
C++线程安全的单例模式讲解
12-31
需要用锁，来保证其线程安全性：原因：多个线程可能进入判断是否已经存在实例的if语句，从而non thread safety。 使用double-check来保证thread safety。但是如果处理大量数据时，该锁才成为严重的性能瓶颈。 1、...
【C++ 线程安全的单例模式】【转载】
最新发布
j8267643的博客
02-20 942
代码如下：​​​​​​​。但是不同的编译器表现是不一样的。线程B执行到语句1，判断instance_此时不为空，则返回该变量，然后调用该对象的函数，但是该对象还没有进行构造。但是语句1是一个读操作，if (instance_ == nullptr)，这个语句是用来读取instance_这个变量，而这个读操作是没有锁的。实现代码如下：​​​​​​​。代码实现：​​​​​​​。使用饿汉模式实现单例是十分简单的，并且有效避免了线程安全问题，因为将该单例对象定义为static变量，程序启动即将其构造完成了。
单例模式及多线程安全（C++版）
YBAdiam的博客
10-22 924
单例模式 Code // 单例设计模式 class sigleC { public: static sigleC* getInstance() { if (m_instance == nullptr) { m_instance = new sigleC(); static delobj cl; // ...
【C++】单例模式及线程安全
qq_43676757的博客
04-11 1538
单例模式及其下线程安全 本篇目录单例模式及其下线程安全1.设计模式1.1单例模式2.饿汉模式饿汉模式多线程下是否安全饿汉模式优缺点3.懒汉模式（常用）懒汉模式在多线程下是否线程安全如何解决懒汉模式在多线程下的线程安全问题懒汉模式的优缺点 1.设计模式 设计模式： 设计模式（Design Pattern）**是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。**为什么会产生设计模式这样...
C++单例模式——懒汉与饿汉以及线程安全
mrqiuwen的博客
10-31 2331
详细介绍了C++单例模式的饿汉式和懒汉式及其区别；介绍了两种线程安全的懒汉式单例模式；介绍了static变量在Linux进程中的存储
【C++】保证线程安全的单例模式
胖狗子修行之路的博客
04-20 517
C++单例模式的实现
c++单例模式在多线程环境下的安全性
startx_it的专栏
09-03 465
C++单例模式，我们一般不用考虑多线程的情况，一般写为 //.h class CSingleton { protected: CSingleton(void); public: static CSingleton * Instance(); ~CSingleton(void); } //.cpp CSingleton::CSingleton(void) {
C++设计模式之单例模式
路过的熊的博客
06-16 2405
C++设计模式之单例模式
C++ 线程安全的单例模式
techenliu的博客
08-22 170
线程安全的C++单例模式
C++ 单例模式线程安全
05-16
单例模式是一种常见的设计模式，它保证一个类只有一个实例对象，并且提供一个全局访问点。在多线程环境下，需要考虑单例模式的线程安全性，否则可能会出现多个实例对象的情况。 以下是一个线程安全的 C++ 单例模式的示例代码： ```c++ class Singleton { private: static Singleton* instance; static std::mutex mtx; // 互斥锁 Singleton() {} public: static Singleton* getInstance() { if (instance == nullptr) { std::lock_guard<std::mutex> lock(mtx); // 加锁 if (instance == nullptr) { instance = new Singleton(); } } return instance; } }; Singleton* Singleton::instance = nullptr; std::mutex Singleton::mtx; ``` 在上面的代码中，我们使用了 `std::mutex` 类型的互斥锁来保证线程安全。`getInstance()` 方法首先检查实例是否已经存在，如果不存在则加锁创建实例，否则直接返回实例对象。使用 `std::lock_guard<std::mutex>` 可以保证在退出 `getInstance()` 方法时自动释放锁，避免了手动解锁的繁琐操作。 需要注意的是，单例模式的实现方式有很多种，上面的代码只是一种简单的实现方式，具体的实现方式可以根据实际需求来选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值