设计模式之单例模式&线程安全

悠悠 2022-06-12 15:11 264阅读 0赞

## 前言 ##

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例。这种设计模式在写日志记录类的时候有使用。它的UML图如下所示

![SouthEast][]

客户通过调用静态函数getInstance()函数获得类对象的实例，且每次调用的时候都是使用的同一个实例。

## 1. 饥饿模式写法 ##

class Singleton
    {
    public:
    	Singleton()
    	{
    	}
    
    	~Singleton()
    	{
    	}
    
    public:
    	static Singleton* p_instance;
    
    	static Singleton* GetInstance()
    	{
    		return p_instance;
    	}
    };
    
    Singleton* Singleton::p_instance = new Singleton();

这种写法就是所谓的**饥饿模式**，每个对象在没有使用之前就已经初始化了。这就可能带来潜在的性能问题：如果这个对象很大呢？没有使用这个对象之前，就把它加载到了内存中去是一种巨大的浪费。

## 2. 懒汉模式写法 ##

class Singleton
    {
    public:
    	Singleton()
    	{
    	}
    
    	~Singleton()
    	{
    	}
    
    public:
    	static Singleton* p_instance;
    
    	static Singleton* GetInstance()
    	{
    		if (nullptr == p_instance)
    		{
    			p_instance = new Singleton();
    		}
    
    		return p_instance;
    	}
    };
    
    Singleton* Singleton::p_instance = nullptr;

这里采用了一种新的设计思想——**延迟加载**（Lazy-load Singleton）。它使用了延迟加载来保证对象在没有使用之前，是不会进行初始化的。

## 3. 单例模式线程安全问题 ##

**线程安全性存在的原因**：假如有两个线程A和B，首先A调用了GetInstance()函数，发现instance没有被初始化，接下来就开始初始化instance。但是在这时线程B进来了，也发现instance实例没有初始化（线程A中instance的初始化没有完成），因而它也开始初始化instance实例。这样带来的结果就是在多线程的环境下，很可能两个线程同时运行到if (p\_instance == NULL)这一句，导致可能会产生两个实例。于是就要在代码中加锁。

#include <thread>
    #include <mutex>
    
    std::mutex m_mutex;
    
    class Singleton
    {
    public:
    	Singleton()
    	{
    	}
    
    	~Singleton()
    	{
    	}
    
    public:
    	static Singleton* p_instance;
    
    	static Singleton* GetInstance()
    	{
    		m_mutex.lock();
    		if (nullptr == p_instance)
    		{
    			p_instance = new Singleton();
    		}
    		m_mutex.unlock();
    
    		return p_instance;
    	}
    };
    
    Singleton* Singleton::p_instance = nullptr;

虽然这样写了是可以满足线程安全性的考量，但是每次进入这个GetInstance()函数**就会加锁解锁**，这就会有开销了。因而这里改进的方向就是减小线程安全的开销。

**同步的代价必然会一定程度的使程序的并发度降低**。那么有没有什么方法，一方面是线程安全的，有可以有很高的并发度呢？我们观察到，线程不安全的原因其实是在初始化对象的时候，所以，可以想办法把同步的粒度降低，只在初始化对象的时候进行同步。这里有必要提出一种新的设计思想——**双重检查锁**（Double-Checked Lock）。

class Singleton
    {
    public:
    	Singleton()
    	{
    	}
    
    	~Singleton()
    	{
    	}
    
    public:
    	static Singleton* p_instance;
    
    	static Singleton* GetInstance()
    	{
    		if (nullptr == p_instance)
    		{
    			m_mutex.lock();
    			if (nullptr == p_instance)
    			{
    				p_instance = new Singleton();
    			}
    			m_mutex.unlock();
    		}
    
    		return p_instance;
    	}
    };
    
    Singleton* Singleton::p_instance = nullptr;

因而将最后的单例模式写成这样就能兼具线程安全和高并发性能了。

[SouthEast]: /images/20220612/9bed09c5d6af427aaa355f23f2f0b617.png