单例模式-C++实现_代码007(未授权)

本文介绍: 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;
}

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;
}

// 双检查锁，但由于内存读写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;
}

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;
}