标签：unlock 做了 argc imp lang opera 验证 ash 状态
前两天，一个C++ 的单例实现又掉坑里了。做好一个安全的单例模式可并不简单。这里总结一下C++ 的几个单例实现方案。
利用单例函数的静态变量，实现单例构造。代码如下：
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);
};
这里利用函数的静态变量，只会存在一份的特性，来实现单例的构造。代码直接明了。
利用类的静态变量的全局唯一性，来实现单例的构造。代码如下：
//
// StaticMemberSingleton.h
//
#ifndef StaticMemberSingleton_h
#define StaticMemberSingleton_h
class 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;让我们用代码来验证一下，我们构造两个单例：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一般常见的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;
}注意：
我们在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 函数更加没有得到执行。
自然我们这时候，执行加锁操作就会引发异常了。
简单总结一下，使用c++ 单例一些需要注意的地方：
标签：unlock 做了 argc imp lang opera 验证 ash 状态
原文地址：http://www.cnblogs.com/rivermoon/p/7072564.html
