【C++设计模式】4.10-单例模式（Singleton）

一、模式介绍

定义

        单例模式又称单件模式、Singleton，是一种创建型设计模式， 能够保证一个类只有一个实例， 并提供一个可以安全访问该实例的全局节点。

类比

        政府是单例模式的一个很好的示例。一个国家只有一个官方政府。不管组成政府的每个人的身份是什么，“某政府” 这一称谓总是作为掌权者的全局访问节点。

适用场景

• 如果程序中的某个类对于所有客户端只有一个可用的实例。
  单例模式禁止通过除特殊构建方法以外的任何方式来创建自身类的对象。 该方法可以创建一个新对象， 但如果该对象已经被创建， 则返回已有的对象。
• 需要更加严格地控制全局变量。
  单例模式与全局变量不同， 它保证类只存在一个实例。 除了单例类自己以外， 无法通过任何方式替换缓存的实例。

可以通过修改获取实例的方法设定并限制生成单例实例的数量。

二、问题及动机

        软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、良好的效率。如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？而解决这一问题是类设计者的责任，而不是使用者的责任。
1. 保证一个类只有一个实例。
        为什么要控制一个类所拥有的实例数量？ 如，当控制某些或某个共享资源 （例如数据库或文件） 的访问权限时，我们只需要使用到一个可以访问该资源的对象。
        其运作方式如下，如果已经创建了一个对象， 同时过一会儿后再创建一个新对象， 此时获得的是之前已创建的对象， 而不是一个新对象。
        普通构造函数无法实现上述行为， 因为构造函数的设计决定了它必须总是返回一个新对象。
2. 为该实例提供全局（安全）访问节点。
        全局变量可以提供全局访问，但非常不安全， 因为任何代码都有可能覆盖掉那些变量的内容， 从而引发程序崩溃。
        单例模式允许在程序的任何地方访问特定对象，同时可以保护该实例不被其他代码覆盖。
        不希望解决同一个问题的代码分散在程序各处的。 因此更好的方式是将其放在同一个类中，特别是当其他代码已经依赖这个类时更应该如此。

三、解决方案

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

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

四、模式结构

1. 单例（Singleton）类声明了一个名为get­Instance获取实例的静态方法来返回其所属类的一个相同实例。

        单例的构造函数必须对客户端（Client）代码隐藏（delete或设置为private）。调用获取实例方法必须是获取单例对象的唯一方式。

五、示例代码

        示例代码中分别使用非线程安全的无锁、线程安全的单检查锁、非线程安全的双检查锁、线程安全的双检查锁实现GetInstance()方法。

• 无锁。只允许在单线程情况下使用。
• 单检查锁。在高并发情况下（如web上同时十万人访问一个地方）会造成不必要的开销（正常情况下只需要在创建实例前锁一次，创建实例后解锁一次，而单检查锁会重复lock、unlock）。
• 非线程安全的双检查锁。可以避免在高并发情况下产生不必要的开销，但存在内存reorder的问题。所为reorder，是由于部分编译器对代码转汇编时进行优化，使得正常情况下指令运行步骤发生了变化所导致。如，正常情况下pinstance_ = new Singleton(value)指令序列运行顺序为分配内存、调用Singleton构造器对刚刚申请的内存进行初始化、将内存地址返回并赋值给pinstance_，而当部分编译器对代码进行优化后的运行顺序变为分配内存、将内存地址返回并赋值给pinstance_、调用Singleton构造器对刚刚申请的内存进行初始化，此时即使pinstance_不为nullptr，由于其所指向的内存有未初始化的可能，当实例不为空但其内存未初始化时另外一个线程进行使用就会导致程序异常。
• 线程安全的双检查锁。C++可以使用volatile关键字避免reorder问题，但仅在MSVC编译器下有用，不能实现跨平台。而C++11及之后可使用std::atomic实现线程同步避免reorder问题出现。示例代码中使用后者实现GetInstance()。

#define THREADTYPE 0 //确定编译哪部分代码

/**
 * Singleton类定义了GetInstance方法
 * 替代构造函数，让客户端可以一次又一次的访问同一个类实例对象。
 */
class Singleton
{
    /**
     * Singleton的构造函数/析构函数应该始终是私有的
	 * 防止使用操作符'new'/'delete'直接构造/销毁调用。
     */
private:
#if THREADTYPE == 1 //单检查锁
    static Singleton* pinstance_;//实例指针
    static std::mutex mutex_;//互斥锁
#elif THREADTYPE == 2 //非线程安全双检查锁
    static Singleton* pinstance_;
    static std::mutex mutex_;
#elif THREADTYPE == 3 //线程安全双检查锁
	static std::atomic<Singleton*> pinstance_;
	static std::mutex mutex_
#endif
protected:
    Singleton(const std::string value): value_(value)
    {
    }
    ~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_;
    } 
};

/**
 * 静态方法或成员需要在类外部定义。
 */
#if THREADTYPE == 0 //无锁
Singleton *Singleton::GetInstance(const std::string& value)
{
    if (pinstance_ == nullptr)
    {
        pinstance_ = new Singleton(value);
    }
    return pinstance_;
}
#elif THREADTYPE == 1 //单检查锁
Singleton* Singleton::pinstance_{nullptr};
std::mutex Singleton::mutex_;
Singleton *Singleton::GetInstance(const std::string& value)
{
    std::lock_guard<std::mutex> lock(mutex_);
    if (pinstance_ == nullptr)
    {
        pinstance_ = new Singleton(value);
    }
    return pinstance_;
}
#elif THREADTYPE == 2 //非线程安全双检查锁
Singleton* Singleton::pinstance_{nullptr};
std::mutex Singleton::mutex_;
Singleton *Singleton::GetInstance(const std::string& value)
{
    if (pinstance_ == nullptr)
    {
    	std::lock_guard<std::mutex> lock(mutex_);
    	if(pinstance_ == nullptr)
    	{
			pinstance_ = new Singleton(value);
		}
    }
    return pinstance_;
}
#elif THREADTYPE == 3 //线程安全双检查锁
std::atomic<Singleton*> Singleton::pinstance_;
std::mutex Singleton::mutex_;
Singleton* Singleton::GetInstance(const std::string& value)
{
	Singleton* tmp = pinstance_.load(std::memory_order_relaxed);
	std::atomic_thread_fence(std::memory_order_acquire);//获取内存fence（屏障）
	if (tmp == nullptr) {
		std::lock_guard<std::mutex> lock(mutex_);
		tmp = m_instance.load(std::memory_order_relaxed);
		if (tmp == nullptr) {
			tmp = new Singleton(value);
			std::atomic_thread_fence(memory_order_release);	//释放内存fence（屏障）
			m_instance.store(tmp, std::memory_order_relaxed);
		}
	}
	return tmp;
}
#endif

void ThreadFoo(){
    // 慢初始化，GetInstance中没加锁时会同时创建
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    Singleton* singleton = Singleton::GetInstance("FOO");
    std::cout << singleton->value() << "\n";
}

void ThreadBar(){
    // 慢初始化，GetInstance中没加锁时会同时创建
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    Singleton* singleton = Singleton::GetInstance("BAR");
    std::cout << singleton->value() << "\n";
}

int main()
{   
    std::cout <<"If you see the same value, then singleton was reused (yay!\n" <<
                "If you see different values, then 2 singletons were created (booo!!)\n\n" <<
                "RESULT:\n";   
    // 无锁状态下输出的value不一样
    std::thread t1(ThreadFoo);
    std::thread t2(ThreadBar);
    t1.join();
    t2.join();
    
    return 0;
}

六、优缺点

优点

• 可以保证一个类只有一个实例。
• 获得一个指向该实例的全局访问节点。
• 仅在首次请求单例对象时对其进行初始化。

缺点

• 违反了单一职责原则。 该模式同时解决了两个问题。
• 单例模式可能掩盖不良设计， 比如程序各组件之间相互了解过多等。
• 该模式在多线程环境下需要进行特殊处理， 避免多个线程多次创建单例对象。
• 单例的客户端代码单元测试可能会比较困难， 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。

七、模式关系

• 外观模式类通常可以转换为单例模式类， 因为在大部分情况下一个外观对象就足够了。
• 如果能将对象的所有共享状态简化为一个享元对象， 那么享元模式就和单例类似。 但这两个模式有两个根本性的不同。
  1. 只会有一个单例实体， 但是享元类可以有多个实体， 各实体的内在状态也可以不同。
  2. 单例对象可以是可变的。 享元对象是不可变的。
• 抽象工厂模式、 生成器模式和原型模式都可以用单例来实现。

参考：
1、https://refactoringguru.cn/design-patterns/singleton
2、https://blog.csdn.net/u012011079/article/details/126013168