亦称： 单件模式、Singleton

意图

单例的特点是只提供唯一一个类的实例，具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例。

什么时候使用单例

具体运用场景如：

• 设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;

• 数据池，用来缓存数据的数据结构，需要在一处写，多处读取;

单例模式的实现

所有单例的实现都包含以下两个相同的步骤：

• 将默认构造函数设为私有， 防止其他对象使用单例类的 new运算符。
• 新建一个静态构建方法作为构造函数。 该函数会 “偷偷” 调用私有构造函数来创建对象， 并将其保存在一个静态成员变量中。 此后所有对于该函数的调用都将返回这一缓存对象。

如果你的代码能够访问单例类， 那它就能调用单例类的静态方法。 无论何时调用该方法， 它总是会返回相同的对象。

1、有缺陷的懒汉式

懒汉式的方法是直到使用时才实例化对象，也就是直到调用GetInstance()方法时才new一个单例的对象。

class Singleton
{
protected:
	Singleton(const std::string value) :value_(value)
	{

	}
	
	static Singleton* singleton_;

	std::string value_;

public:
	Singleton(Singleton &other) = delete;

	void operator=(const Singleton &) = delete;

	static Singleton *GetInstance(const std::string& value);

	void SomeBusinessLogic()
	{
		// ...
	}

	std::string value() const {
		return value_;
	}
};

Singleton* Singleton::singleton_ = nullptr;;

Singleton *Singleton::GetInstance(const std::string& value)
{
	if (singleton_ == nullptr) 
	{
		singleton_ = new Singleton(value);
	}
	return singleton_;
}

这是个最基础版本的实现，存在以下2个问题：

1）线程安全的问题，当多线程获取单例时有可能引发竞态条件：第一个线程在if中判断 singleton_是空的，于是开始实例化单例；同时第2个线程也尝试获取单例，这个时候判断singleton_还是空的，于是也开始实例化单例；这样就会实例化出两个对象，这就是线程安全问题的由来。解决办法:加锁；

2）内存泄漏，注意到类中只负责new出对象，却没有负责delete对象，因此只有构造函数被调用，析构函数却没有被调用；因此会导致内存泄漏。解决办法： 使用共享指针;

因此，这里提供一个改进的，线程安全的、使用智能指针的实现;

2、线程安全、内存安全的懒汉式单例 （智能指针，锁）

class Singleton
{
public:
    //typedef std::shared_ptr<Singleton> Ptr;
    using Ptr = std::shared_ptr<Singleton>;
 
    ~Singleton(){
        std::cout<<"destructor called!"<<std::endl;
    }
 
    Singleton(Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
 
    static Ptr getInstance()
    {
        // 双重锁
        if(m_pInstance==nullptr){
            std::lock_guard<std::mutex> lk(m_mutex);
 
            if(m_pInstance == nullptr){
                m_pInstance = std::shared_ptr<Singleton>(new Singleton);
            }
        }
 
        return m_pInstance;
    }
 
private:
    Singleton() {
        std::cout << "constructor called!" << std::endl;
    }
 
private:
    static Ptr m_pInstance;
    static std::mutex m_mutex;
};
 
// initialization static variables out of class
Singleton::Ptr Singleton::m_pInstance = nullptr;
std::mutex Singleton::m_mutex;

shared_ptr和mutex都是C++11的标准，以上这种方法的优点是：

1）基于 shared_ptr, 用了C++比较倡导的 RAII思想，用对象管理资源,当 shared_ptr 析构的时候，new 出来的对象也会被 delete掉。以此避免内存泄漏。

2）加了锁，使用互斥量来达到线程安全。这里使用了两个 if判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，避免每次调用 get_instance的方法都加锁，锁的开销毕竟还是有点大的。

不足之处在于： 使用智能指针会要求用户也得使用智能指针，非必要不应该提出这种约束; 使用锁也有开销; 同时代码量也增多了，实现上我们希望越简单越好。还有更加严重的问题，在某些平台（与编译器和指令集架构有关），双检锁会失效！

因此这里还有第三种的基于 Magic Static的方法达到线程安全。

3、最推荐的懒汉式单例(magic static )——局部静态变量

class Singleton
{
private:
	Singleton() = default;
	~Singleton() = default;

public:
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	static Singleton& GetInstance()
	{
		static Singleton instance;
		return instance;
	}
};

static Singleton* get_instance()
{
    static Singleton instance;
    return &instance;
}

4、单例模式模板类的实现

template<typename T>
class Singleton {
public:
	static T& getInstance() {
		static T instance;
		return instance;
	}

	virtual ~Singleton() {
		std::cout << "destructor called!" << std::endl;
	}

	Singleton(const Singleton&) = delete;
	Singleton& operator =(const Singleton&) = delete;

protected:
	Singleton() {
		std::cout << "constructor called!" << std::endl;
	}
};

/********************************************/
// Example:
// 1.friend class declaration is requiered!
// 2.constructor should be private

class DerivedSingle : public Singleton<DerivedSingle> {
	// !!!! attention!!!
	// needs to be friend in order to
	// access the private constructor/destructor
	friend class Singleton<DerivedSingle>;

public:
	DerivedSingle(const DerivedSingle&) = delete;
	DerivedSingle& operator =(const DerivedSingle&) = delete;

private:
	DerivedSingle() = default;
};

以上实现一个单例的模板基类，使用方法如例子所示意，子类需要将自己作为模板参数T 传递给 Singleton 模板; 同时需要将基类声明为友元，这样才能调用子类的私有构造函数。

基类模板的实现要点是：

• 构造函数需要是 protected，这样子类才能继承；

• 使用了奇异递归模板模式CRTP(Curiously recurring template pattern)

在这里基类的析构函数可以不需要 virtual ，因为子类在应用中只会用 Derived 类型，保证了析构时和构造时的类型一致。

5、不需要在子类声明友元的实现方法

在 stackoverflow上， 有大神给出了不需要在子类中声明友元的方法，在这里一并放出；精髓在于使用一个代理类 token，子类构造函数需要传递token类才能构造，但是把 token保护其起来， 然后子类的构造函数就可以是公有的了，这个子类只有 Derived(token)的这样的构造函数，这样用户就无法自己定义一个类的实例了，起到控制其唯一性的作用。

template<typename T>
class Singleton {
public:
	//  C++ STL的std::is_nothrow_constructible模板用于检查给定类型T是否是带有参数集的可构造类型，并且众所周知，它不会引发任何异常。如果T为可构造类型，则返回布尔值true，否则返回false。
	static T& getInstance() noexcept(std::is_nothrow_constructible<T>::value)
	{
		
		static T instance{token()};
		return instance;
	}

	virtual ~Singleton() = default;

	Singleton(const Singleton&) = delete;
	Singleton& operator =(const Singleton&) = delete;

protected:
	struct token {}; // helper class
	Singleton() noexcept = default;
};

/********************************************/
// Example:
// constructor should be public because protected `token` control the access

class DerivedSingle : public Singleton<DerivedSingle> {

public:
	DerivedSingle(token) {
		std::cout << "destructor called!" << std::endl;
	}

	~DerivedSingle() {
		std::cout << "constructor called!" << std::endl;
	}
	DerivedSingle(const DerivedSingle&) = delete;
	DerivedSingle& operator =(const DerivedSingle&) = delete;
};

单例模式的优缺点