设计模式（四）:单例模式

单例模式

定义

保证一个类仅有一个实例，并提供一个该实例的全局访问点。 ——《设计模式》GoF

使用背景

某些在代码中只会出现一个的实例

结构图

有问题的单例模式实现

这里会出现几种单例模式的写法，都有不同的问题

（一）：不支持多线程以及存在内存泄漏危险的单例模式

class Singleton {
public:
    static Singleton* GetInstance() 
    {
        if (_instance == nullptr) 
        { 
            _instance = new Singleton(); 
        }
        return _instance; 
    } 
private: 
    Singleton() {} //构造
    ~Singleton() { cout << "~Singleton" << endl; }
    Singleton(const Singleton &clone){} //拷⻉构造 
    Singleton& operator=(const Singleton&) {} 
    static Singleton * _instance;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

不支持多线程：当两个线程进入if (_instance == nullptr) 后，都会new一个新的实例出来，导致单例模式失效。
内存泄漏：_instance = new Singleton(); new出来的对象存放在堆区，而static Singleton * _instance;则存放在全局区，所以变量在并不会调用析构函数导致内存泄露。

（一）：解决上面内存泄漏问题后的单例模式

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() {}
    Singleton(const Singleton& cpy);//拷⻉构造
    Singleton& operator=(const Singleton& other) {}
    static Singleton* _instance;
};
Singleton* Singleton::_instance = nullptr;

这里用atexit函数注册了一个在程序运行结束后调用的函数 static void Destructor()，把_instance变量析构。但程序依旧还有多线程问题。

（三）懒汉模式（解决上面多线程问题的单例模式），但是会存在cpu reorder问题。

class Singleton { 
	// 懒汉模式 lazy load 
public: 
	static Singleton * GetInstance()
	{ 
		if (_instance == nullptr) 
		{ 
			std::lock_guard<std::mutex> lock(_mutex);
			if (_instance == nullptr)
			{ 
				_instance = new Singleton(); 
				// 1. 分配内存
				// 2. 调用构造函数 
				// 3. 返回指针 
				// 多线程环境下 cpu reorder操作 
				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;

这里采用两个if (_instance == nullptr)判断，第一个if是为了减少加锁的次数，第二个if是为了防止两个线程同时进入if后获取锁而实例化多个对象。但这个代码在多线程的情况下会在_instance = new Singleton();处出现cpu reorder问题，也就是cpu自动优化内部汇编代码导致new的顺序从// 1. 分配内存// 2. 调用构造函数 // 3. 返回指针 变成// 1. 分配内存//2. 返回指针// 3. 调用构造函数 ，函数可能在2这里就返回出去，使得我们的对象没有初始化，产生问题。

解决了问题后的单例模式代码

（一）

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;

针对cpu reorder问题我们在这里加上了内存屏障，自此单例模式所有存在的问题都得到了解决。

（二）代码更少，性能相同的单例模式

class Singleton 
{ 
public:
	static Singleton& GetInstance() 
	{ 
		static Singleton instance;
		return instance; 
	} 
private: 
	Singleton() {} 
	~Singleton() {}
	Singleton(const Singleton&) {} 
	Singleton& operator=(const Singleton&) {} 
};

这里采用 引用的方式返回，因为在c++11有了 magic static 特性（如果当变量在初始化的时候，并发同时进⼊声明语句，并发线程将 会阻塞等待初始化结束）
这样就解决了多线程、new导致的cpu reorder问题以及内存泄漏问题。可谓是最优方案。

（二）将单例模式抽象，当需要的时候直接去继承它

template<typename T>
class Singleton
{
public:
    static T& GetInstance()
    {
        static T instance;
        return instance;
    }
protected:
    virtual ~Singleton() { }
    Singleton() {  } // protected修饰构造函数，才能让别⼈继承
    Singleton(const single&) {  }
    Singleton& operator =(const Singleton&) {  }


};
class DesignPattern : public Singleton<DesignPattern>
{
    friend class Singleton<DesignPattern>;
public:
    ~DesignPattern() {}
private: 
    DesignPattern() { }
    DesignPattern(const DesignPattern&) {  }
    DesignPattern& operator=(const DesignPattern&) { }
};

这样的话当我们需要单例模式的时候就直接继承单例父类就行了，简单方便！