（一）创建型设计模式：2、单例模式（C++实现实例 线程安全）

目录

1、单例模式（Singleton Pattern）的含义

2、单例模式的优缺点

（1）优点：

（2）缺点：

3、C++实现单例模式的示例（简单）

4、C++实现单例模式的示例（实际项目中使用）

（1）构造一个单例基类（无线程安全）

（2）构造一个单例基类（二次保证线程安全）

（3）目标类成为单例类，继承这个单例类即可

（4）如何使用这个目标单例类

---

1、单例模式（Singleton Pattern）的含义

（1）单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。

（2）单例模式的主要目的是限制一个类的实例化次数，以便在整个应用程序中共享该实例。它常用于需要全局访问某个对象的场景，例如日志记录器、数据库连接池等。

2、单例模式的优缺点

（1）优点：

1）全局访问：单例模式可以提供一个全局访问点，使得其他对象可以方便地访问该实例。

2）节省资源：由于单例模式只创建一个实例，可以节省系统资源，特别是在需要频繁创建和销毁对象的场景下。

3）数据共享：单例模式可以实现数据的共享，多个对象可以共享同一个实例，避免了数据不一致的问题。

4）延迟实例化：单例模式可以延迟实例化，即在第一次使用时才创建实例，提高了系统的性能和效率。

（2）缺点：

1）难以扩展：由于单例模式只允许存在一个实例，因此扩展时可能会受到限制。

2）违反单一职责原则：单例模式将创建实例和业务逻辑耦合在一起，违反了单一职责原则，增加了代码的复杂性和维护成本。

3）对象生命周期管理困难：由于单例模式的实例在整个应用程序的生命周期中存在，因此对其生命周期的管理可能较为困难。

4）可能引发线程安全问题：在多线程环境下，如果没有正确处理并发访问的情况，可能会引发线程安全问题。

因此，在使用单例模式时需要权衡其优缺点，并根据具体的业务需求和场景来决定是否使用。

3、C++实现单例模式的示例（简单）

class Singleton 
{
private:
	static Singleton* instance; // 静态成员变量，保存唯一实例的指针
	// 将构造函数和拷贝构造函数声明为私有，防止外部直接实例化和复制对象
	Singleton() {}
	Singleton(const Singleton& other) {}

public:
	static Singleton* getInstance()
	{
		if (instance == nullptr)
		{
			instance = new Singleton();
		}
		return instance;
	}

	void someMethod() 
	{
		// 单例类的其他方法
	}
};

Singleton* Singleton::instance = nullptr; // 初始化静态成员变量

int main() 
{
	Singleton* obj1 = Singleton::getInstance(); // 获取单例实例
	obj1->someMethod(); // 调用单例对象的方法
	Singleton* obj2 = Singleton::getInstance(); // 再次获取单例实例，与obj1相同
	return 0;
}

在上述示例中，通过将构造函数和拷贝构造函数声明为私有，外部无法直接实例化和复制对象。通过静态成员变量instance保存唯一实例的指针，并提供静态方法getInstance()来获取该实例。

4、C++实现单例模式的示例（实际项目中使用）

（1）构造一个单例基类（无线程安全）

/*
单例类
*/
#pragma once
#include <map>
#include <string>
#include <vector>
using namespace std;

template <typename T>
class SingleTon
{
public:
	static T* getInstance()
	{
		if (NULL == m_pInstance)
		{
			//m_singleCS.Lock();
			if (NULL == m_pInstance)
			{
				m_pInstance = new T();
			}
			//m_singleCS.Unlock();
		}
		return m_pInstance;
	}

protected:
	SingleTon(void){}
	virtual ~SingleTon(void){
		if (NULL != m_pInstance)
		{
			delete m_pInstance;
			m_pInstance = NULL;
		}
	}

	static T* m_pInstance;

private:
	SingleTon(const SingleTon&);
	SingleTon& operator = (const SingleTon&);
};

template <typename T>
T* SingleTon<T>::m_pInstance = NULL;

（2）构造一个单例基类（二次保证线程安全）

/*
 * @Description: 单例类工厂
 * @Author: Ivy
 * @Date: 2023-05-09 09:34:43
 * @LastEditTime: 2023-02-24 11:28:29
 * @LastEditors: XTZJ-2022OQEHLZ
 */
#pragma once
#include <vector>
#include <string>
#include <iostream>
#include <QMutex>

using namespace std;
template <typename T>
class Singleton
{
public:
    static T* getInstance()
    {
        if (m_pInstance == NULL)
        {
            // 二次保证线程安全
            m_pMutexCreate.lock();
            if (m_pInstance == NULL)
            {
                m_pInstance = new T();
            }
            m_pMutexCreate.unlock();
        }
        return m_pInstance;
    }

    // 尽量多的将单例共有的方法放到基类，子类继承即可
    virtual void startWork() {}
protected:
    Singleton() {}
    virtual ~Singleton()
    {
        if (m_pInstance != NULL)
        {
            delete [] m_pInstance;
            m_pInstance = NULL;
        }
    }

    static T* m_pInstance;
    static QMutex m_pMutexCreate;
    QMutex m_mutex;
private:
    Singleton(const Singleton&);
    Singleton& operator =(const Singleton&);

public:
    void lock() { m_mutex.lock(); }
    void unLock() { m_mutex.unlock(); }
};

template <typename T>
QMutex Singleton<T>::m_pMutexCreate;

template <typename T>
T* Singleton<T>::m_pInstance = NULL;

（3）目标类成为单例类，继承这个单例类即可

/*
 * @Description: XXX 管理类
 */
#pragma once
#include "Singleton.h"

class testManager : public Singleton<testManager>
{
    friend class Singleton<testManager>;//要声明友元类
	
public:
    virtual ~testManager();
	
	void getData();
	void setData();
	
private:
    testManager();
}

（4）如何使用这个目标单例类

// 实例演示：包含该类的头文件
testManager::getInstance()->getData();