C++ 安全单例模式总结-白红宇

C++ 安全单例模式总结

阅读量：4327 次

发布时间：2019-06-06

本文共 5708 字，大约阅读时间需要 19 分钟。

前两天，一个C++ 的单例实现又掉坑里了。做好一个安全的单例模式可并不简单。这里总结一下C++ 的几个单例实现方案。

1. 函数静态变量法

利用单例函数的静态变量，实现单例构造。代码如下：

class StaticVarSingleTon {public:    static StaticVarSingleTon *GetInstance() {        static StaticVarSingleTon s_instance;        return &s_instance;    }    private:    StaticVarSingleTon() {}    virtual ~StaticVarSingleTon() {};    StaticVarSingleTon(const StaticVarSingleTon &);    StaticVarSingleTon& operator=(const StaticVarSingleTon& other);};

这里利用函数的静态变量，只会存在一份的特性，来实现单例的构造。代码直接明了。

优点

代码简单，直接明了

还是个懒加载模式

缺点

静态变量的构造，不是线程安全的。

2. 类静态成员变量

利用类的静态变量的全局唯一性，来实现单例的构造。代码如下：

////  StaticMemberSingleton.h//#ifndef StaticMemberSingleton_h#define StaticMemberSingleton_hclass StaticMemberSingleTon {public:    static StaticMemberSingleTon *GetInstance() {        return &s_instance;    }    private:    StaticMemberSingleTon() {}    virtual ~StaticMemberSingleTon() {};    StaticMemberSingleTon(const StaticMemberSingleTon &);    StaticMemberSingleTon& operator=(const StaticMemberSingleTon& other);    private:    static StaticMemberSingleTon s_instance;};#endif /* StaticMemberSingleton_h*/

////  StaticMemberSingleton.cpp//#include "StaticMemberSingleton.h"StaticMemberSingleTon StaticMemberSingleTon::s_instance;

优点

这里的StaticMemberSingleTon StaticMemberSingleTon::s_instance 是一个全局变量。只会出现一份。

全局变量的初始化，在main 函数执行之前完成。可以保证线程安全。

缺点

当有另外一个 StaticMemberSingletonB，在构造函数中依赖 StaticMemberSingletonA 的单例对象时，可能出现StaticMemberSingletonA 的单例对象还没有初始化的问题。

让我们用代码来验证一下，我们构造两个单例：StaticMemberSingletonA， StaticMemberSingletonB.

StaticMemberSingletonA 的构造函数，调用StaticMemberSingletonB 的方法；

StaticMemberSingletonB 的构造函数，调用StaticMemberSingletonA 的方法。

代码如下。

////  StaticMemberSingletonA.h//#ifndef StaticMemberSingletonA_h#define StaticMemberSingletonA_h#include 
     
      class StaticMemberSingleTonA {public:    static StaticMemberSingleTonA *GetInstance() {        return &s_instance;    }        void showValue() {        printf("SingleTonA value %d\n", value);    }    private:    StaticMemberSingleTonA();        virtual ~StaticMemberSingleTonA() {};    StaticMemberSingleTonA(const StaticMemberSingleTonA &);    StaticMemberSingleTonA& operator=(const StaticMemberSingleTonA& other);    private:    static StaticMemberSingleTonA s_instance;    private:    int value = 0;};#endif /* StaticMemberSingletonA_h*/

////  StaticMemberSingletonA.cpp//#include "StaticMemberSingletonA.h"#include "StaticMemberSingletonB.h"StaticMemberSingleTonA StaticMemberSingleTonA::s_instance;StaticMemberSingleTonA::StaticMemberSingleTonA() {    value = 1;        StaticMemberSingleTonB::GetInstance()->showValue();}

////  StaticMemberSingletonB.h//#ifndef StaticMemberSingletonB_h#define StaticMemberSingletonB_h#include 
     
      class StaticMemberSingleTonB {public:    static StaticMemberSingleTonB *GetInstance() {        return &s_instance;    }        void showValue() {        printf("SingleTonB value %d\n", value);    }    private:    StaticMemberSingleTonB();        virtual ~StaticMemberSingleTonB() {};    StaticMemberSingleTonB(const StaticMemberSingleTonB &);    StaticMemberSingleTonB& operator=(const StaticMemberSingleTonB& other);    private:    static StaticMemberSingleTonB s_instance;    private:    int value = 0;};#endif /* StaticMemberSingletonB_h*/

////  StaticMemberSingletonB.cpp//#include "StaticMemberSingletonB.h"#include "StaticMemberSingletonA.h"StaticMemberSingleTonB StaticMemberSingleTonB::s_instance;StaticMemberSingleTonB::StaticMemberSingleTonB() {    value = 2;    StaticMemberSingleTonA::GetInstance()->showValue();}

////  main.cpp//#include 
     
      #include "StaticMemberSingletonA.h"int main(int argc, const char * argv[]) {    StaticMemberSingleTonA::GetInstance();    return 0;}

执行一下，结果如下：

SingleTonA value 0SingleTonB value 2Program ended with exit code: 0

3. 线程安全的单例方法

一般常见的C++ 线程安全的单例实现代码，如下：

////  SafeSingleton.h//#ifndef SafeSingleton_h#define SafeSingleton_h#include "Mutex.h"class SafeSingleton {public:    static SafeSingleton *GetInstance();    private:    SafeSingleton() {};    virtual ~SafeSingleton() {};    SafeSingleton(const SafeSingleton &);    SafeSingleton& operator=(const SafeSingleton& other);    private:    static SafeSingleton *s_instance;    static Mutex          s_insMutex;};#endif /* SafeSingleton_h*/

////  SafeSingleton.cpp//#include "SafeSingleton.h"SafeSingleton *SafeSingleton::s_instance;Mutex          SafeSingleton::s_insMutex;SafeSingleton *SafeSingleton::GetInstance() {    if (s_instance == nullptr) {        s_insMutex.lock();        if (s_instance == nullptr) {            s_instance = new SafeSingleton();        }        s_insMutex.unlock();    }    return s_instance;}

注意：

第一次判断 s_instance 非空，是为了提升性能，避免无谓的加锁。

获得锁后，必须再次判断 s_instance 非空，避免多线程下二次创建。

另外，由于所有实例的构造，都在main函数之后执行了。而锁对象是全局变量，在main 之前就已经完成初始化了，不会出现方案2 中的对象未初始化现象。

当然，如果真这儿做了，会出现死锁。

4. 还未结束

我们在C++ 层实现了一个网络状态监控模块，这个模块给iOS 业务层使用。当时业务层实现了自己的一个网络状态模块。大致代码如下所示：

@implementation IOSNetworkState+ (void)load {    [IOSNetworkState sharedInstance];}+ (instancetype)sharedInstance {    static IOSNetworkState *instance;    static dispatch_once_t onceToken;    dispatch_once(&onceToken, ^{        instance = [[IOSNetworkState alloc] init];    });    return instance;}- (instancetype)init {    self = [super init];    if (self) {        Network::NetworkMonitor::GetInstance()->DoXXX();    }    return self;}

然后就悲剧了，APP 起来就crash。crash 的位置是，执行 Network::NetworkMonitor::GetInstance() 方法时，加锁操作crash。原因是Mutex 对象未初始化。

原来，OC 类的 +(void)load 方法，其执行时期是类的加载期。比全局对象（就是我们的Mutex）的初始化要早。当然这个时候，main 函数更加没有得到执行。

自然我们这时候，执行加锁操作就会引发异常了。

5. 总结

简单总结一下，使用c++ 单例一些需要注意的地方：

一：使用线程安全的单例方法。

二：尽量避免在单例类的构造方法中，使用其他的单例对象。

三：不要在类的加载期方法中，使用其他单例对象。其实，在类加载期方法中，不应该涉及业务处理。

转载于:https://www.cnblogs.com/rivermoon/p/7072564.html

你可能感兴趣的文章