C++ 安全单例模式总结

前两天，一个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 <stdio.h>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 <stdio.h>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 <stdio.h>
#include "StaticMemberSingletonA.h"int main(int argc, const char * argv[]) {StaticMemberSingleTonA::GetInstance();return 0;
}

执行一下，结果如下：

SingleTonA value 0
SingleTonB value 2
Program 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