设计模式-单例模式

1.单例模式定义

保证⼀个类仅有⼀个实例，并提供⼀个该实例的全局访问点。

2.单例模式遵循的模式设计原则

3.要点

4.本质

5.代码

5.1 版本1

// 内存栈区
// 内存堆区
// 常数区
// 静态区 系统释放
// ⼆进制代码区
class Singleton {
	public:
	static Singleton * GetInstance() {
	if (_instance == nullptr) {
		_instance = new Singleton();
		}
	return _instance;
	}
private:
Singleton(){}//构造
Singleton(const Singleton &clone){} //拷⻉构造
Singleton& operator=(const Singleton&) {}
static Singleton * _instance;
}
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

版本1存在的问题：
a.有内存泄漏的问题，因为new出的对象没有释放；
b.多线程未加锁；

5.1 版本2

class Singleton {
public:
static Singleton * GetInstance() {
	if (_instance == nullptr) {
	_instance = new Singleton();
	atexit(Destructor);
	}
	return _instance;
	}
~Singleton() {}
private:
static void Destructor() {
if (nullptr != _instance) {
	delete _instance;
	_instance = nullptr;
	}
}
Singleton();//构造
Singleton(const Singleton &cpy); //拷⻉构造
Singleton& operator=(const Singleton&) {}
static Singleton * _instance;
}
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
// 还可以使⽤ 内部类，智能指针来解决； 此时还有线程安全问题

版本2存在的问题：
使用atexit()解决内存泄漏的问题；但尚未解决多线程的问题；

5.1 版本3

#include <mutex>
class Singleton { // 懒汉模式 lazy load
public:
static Singleton * GetInstance() {
//std::lock_guard<std::mutex> lock(_mutex); // 3.1 切换线程
if (_instance == nullptr) {
std::lock_guard<std::mutex> lock(_mutex); // 3.2
if (_instance == nullptr) {
_instance = new Singleton();
atexit(Destructor);
}
}
return _instance;
}
private:
static void Destructor() {
if (nullptr != _instance) {
delete _instance;
_instance = nullptr;
}
}
Singleton(){} //构造
Singleton(const Singleton &cpy){} //拷⻉构造
Singleton& operator=(const Singleton&) {}
static Singleton * _instance;
static std::mutex _mutex;
}
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
std::mutex Singleton::_mutex; //互斥锁初始化

版本3存在的问题：
出现cpu指令重排的情况，new操作可分为3步，分配内存->调用构造函数->赋值操作，当CPU指令重排时出现问题；

5.1 版本4

#include <mutex>
#include <atomic>
class Singleton {
public:
static Singleton * GetInstance() {
Singleton* tmp = _instance.load(std::memory_order_relaxed);
std::atomic_thread_fence(std::memory_order_acquire);//获取内存屏障
if (tmp == nullptr) {
std::lock_guard<std::mutex> lock(_mutex);
tmp = _instance.load(std::memory_order_relaxed);
if (tmp == nullptr) {
tmp = new Singleton;
std::atomic_thread_fence(std::memory_order_release);//释放内存屏
障
_instance.store(tmp, std::memory_order_relaxed);
atexit(Destructor);
}
}
return tmp;
}
private:
static void Destructor() {
Singleton* tmp = _instance.load(std::memory_order_relaxed);
if (nullptr != tmp) {
delete tmp;
}
}
Singleton(){}
Singleton(const Singleton&) {}
Singleton& operator=(const Singleton&) {}
static std::atomic<Singleton*> _instance;
static std::mutex _mutex;
};
std::atomic<Singleton*> Singleton::_instance;//静态成员需要初始化
std::mutex Singleton::_mutex; //互斥锁初始化
// g++ Singleton.cpp -o singleton -std=c++11

版本4存在的问题：
使用内存屏障解决内存重排的问题，但代码繁琐；

5.1 版本5

// c++11 magic static 特性：如果当变量在初始化的时候，并发同时进⼊声明语句，并发线程将会阻塞等待初始化结束。
class Singleton
{
public:
~Singleton(){}
static Singleton& GetInstance() {
static Singleton instance;
return instance;
}
private:
Singleton(){}
Singleton(const Singleton&) {}
Singleton& operator=(const Singleton&) {}
};
// 继承 Singleton
// g++ Singleton.cpp -o singleton -std=c++11

版本5 所有优点：
a. 利⽤静态局部变量特性，延迟加载；
b. 利⽤静态局部变量特性，系统⾃动回收内存，⾃动调⽤析构函数；
c. 静态局部变量初始化时，没有 new 操作带来的cpu指令reorder操作；
d. c++11 静态局部变量初始化时，具备线程安全；
版本5存在的问题：
构造函数为私有模式，如果有子类需要继承Singleton时无法初始化；

5.1 版本6

template<typename T>
class Singleton {
public:
static T& GetInstance() {
static T instance; // 这⾥要初始化DesignPattern，需要调⽤DesignPattern 构造函数，同时会调⽤⽗类的构造函数。
return instance;
}
protected:
virtual ~Singleton() {}
Singleton() {} // protected修饰构造函数，才能让别⼈继承
Singleton(const Singleton&) {}
Singleton& operator =(const Singleton&) {}
};
class DesignPattern : public Singleton<DesignPattern> {
friend class Singleton<DesignPattern>; // friend 能让 Singleton<T> 访问到 DesignPattern构造函数
private:
DesignPattern(){}
DesignPattern(const DesignPattern&) {}
DesignPattern& operator=(const DesignPattern&) {}
}