单例模式-C++实现

本文介绍: reorder就是在编译器底层进行优化重排指令的执行顺序。举个例子：这行代码在编译器底层大致可以分为三个步骤：1、分配内存2、调用构造器对内存进行初始化3、将内存的地址赋值给m _in s t ance但在实际的运行过程中，编译器执行的顺序可能是1-》3-》2，这就会导致当多个线程同时调用 getIns t ance 方法并且m _in s t ance为null ptr时，它们可能会同时通过 if语句的判断条件进入临界区。

饿汉式

在饿汉式中，实例在类加载时就被初始化，并且保证在多线程环境下的线程安全。

// 饿汉式
class Singleton {
private:

	static Singleton* instance; // 静态成员变量，保存实例指针
	Singleton() {} // 构造函数私有化
	Singleton(const Singleton&amp; other) {}	// 拷贝构造函数私有化
	Singleton&amp; operator=(const Singleton&amp;) {} // 赋值运算符私有化

public:
	static Singleton* getInstance() {
		return instance;
	}
};

Singleton* Singleton::instance = new Singleton(); // 在类加载时初始化实例

// 使用示例
Singleton* obj1 = Singleton::getInstance();
Singleton* obj2 = Singleton::getInstance();

// obj1 和 obj2 是同一个实例

饿汉式下类的实例对象在类加载时就被创建并赋值给静态成员变量instance，因此不需要考虑线程安全问题。因为每次调用 getInstance方法都会返回同一个实例。

饿汉式的优点是实现简单，线程安全；缺点是无法实现延迟加载，即类在加载时就创建好了实例，可能会浪费资源。

懒汉式

懒汉式的实现方法是将实例的创建延迟到第一次请求访问时再进行初始化，这样可以避免初始化时资源的浪费和额外的开销，但需要考虑多线程之间的线程安全问题。

class Singleton
{
private:
	Singleton() {}
	Singleton(const Singleton&amp; other) {}
	Singleton&amp; operator=(const Singleton&amp;) {} // 赋值运算符私有化
public:
	static Singleton* getInstance();
	static Singleton* Singleton::m_instance;
};

Singleton* Singleton::m_instance = nullptr;

// 线程不安全
Singleton* Singleton::getInstance()
{
	if (m_instance == nullptr)
		m_instance = new Singleton();

	return m_instance;
}

在getInstance方法中，我们先判断 m_instance是否为空，为空就new 一个出来。但是这样在单线程下是安全的，因为m_instance只会被创建一次，在多线程下可能会被创建多次。

双检查锁，线程安全的版本

class Singleton
{
private:
	Singleton() {}
	Singleton(const Singleton&amp; other) {}
	Singleton&amp; operator=(const Singleton&amp;) {} // 赋值运算符私有化
	
public:
	static Singleton* getInstance();

	static Singleton* m_instance;

	static std::mutex m_mutex;
};

Singleton* Singleton::m_instance = nullptr;
std::mutex m_mutex;

// 多线程安全，但锁的代价过高
Singleton* Singleton::getInstance()
{
	std::lock_guard<std::mutex> lock(m_mutex);
	if (m_instance == nullptr)
		m_instance = new Singleton();

	return m_instance;
}

这个版本在多线程下是安全的，因为加锁了，但是在读操作的情况下，也就是如果m_instance直接返回时是不需要加锁的，所以这个版本在高并发的情况下开销很大，很耗时，因为不管是写操作还是读操作都需要加锁减锁。

为了解决这个问题，我们可以使用双检查锁来避免这样的开销问题

// 双检查锁，但由于内存读写reorder不安全
Singleton* Singleton::getInstance()
{
	if (m_instance == nullptr)
	{
		std::lock_guard<std::mutex> lock(m_mutex);

		if (m_instance == nullptr)
			m_instance = new Singleton();
	}

	return m_instance;
}

锁前检查是否为空是为了避免读操作下还进行加锁，锁后检查是为了避免多次创建。

但是这样还是有问题，内存读写 reorder不安全。

什么是reorder？

reorder就是在编译器底层进行优化重排指令的执行顺序。

举个例子：
m_instance = new Singleton();
这行代码在编译器底层大致可以分为三个步骤：
1、分配内存
2、调用构造器对内存进行初始化
3、将内存的地址赋值给m_instance

但在实际的运行过程中，编译器执行的顺序可能是1-》3-》2，这就会导致当多个线程同时调用getInstance方法并且m_instance为nullptr时，它们可能会同时通过if语句的判断条件进入临界区。在这种情况下，第一个线程通过了if语句的条件检查，并在锁内部实例化了Singleton对象。但由于内存读写重排序的存在，编译器或处理器可能会将Singleton对象的初始化操作重排到锁的外部，这会导致第二个线程在第一个线程完成实例化之前通过了if语句的条件检查，直接返回使用，但此时m_instance还没有进行初始化。

解决内存读写 reorder不安全方法

为了解决这个问题，我们可以使用如下代码实现，支持C11以上版本并跨平台

class Singleton
{
private:
	Singleton();
	Singleton(const Singleton&amp; other);

public:
	static Singleton* getInstance();

	static std::atomic<Singleton*> m_instance;

	static std::mutex m_mutex;
};

std::atomic<Singleton*> Singleton::m_instance;
std::mutex m_mutex;

Singleton* Singleton::getInstance()
{
	Singleton* tmp = m_instance.load(std::memory_order_relaxed);
	std::atomic_thread_fence(std::memory_order_acquire);

	if (tmp == nullptr)
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		tmp = m_instance.load(std::memory_order_relaxed);

		if (tmp == nullptr)
		{
			tmp = new Singleton;
			std::atomic_thread_fence(std::memory_order_release);
			m_instance.store(tmp, std::memory_order_relaxed);
		}
	}

	return tmp;
}