Qt使用单例模式读取xml文件

一、单例模式介绍

1、什么是单例模式

单例模式是指在整个系统生命周期内，保证一个类只能产生一个实例，确保该类的唯一性。

2、为什么使用单例模式

1、节省资源。一个类只有一个实例，不存在多份实例，节省资源。
2、方便控制。在一些操作公共资源的场景时，避免了多个对象引起的复杂操作。

3、什么情况下使用单例模式

在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

4、使用单例模式需要注意哪些问题

线程安全

• 什么是线程安全

在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

• 如何保证线程安全

1、给共享的资源加把锁，保证每个资源变量每时每刻至多被一个线程占用。
2、让线程也拥有资源，不用去共享进程中的资源。如：使用threadlocal可以为每个线程维护一个私有的本地变量。

5、单例模式的类型

• 懒汉式

系统运行中，实例并不存在，只有当需要使用该实例时，才会去创建并使用实例。这种方式要考虑线程安全。

• 饿汉式

系统一运行，就初始化创建实例，当需要时，直接调用即可。这种方式本身就线程安全，没有多线程的线程安全问题。

6、单例类的特点

• 构造函数和析构函数为私有类型，目的是禁止外部构造和析构。
• 拷贝构造函数和赋值构造函数是私有类型，目的是禁止外部拷贝和赋值，确保实例的唯一性。
• 类中有一个获取实例的静态方法，可以全局访问。

2、单例模式的实现

2.1懒汉式

Created with Raphaël 2.3.0 开始 使用单例对象 单例对象是否实例化? 返回单例对象 实例化单例对象 yes no

加锁的懒汉式单例（线程安全）
头文件：

///  加锁的懒汉式实现  //

class SingleInstance
{

public:
    // 获取单实例对象
    static SingleInstance *GetInstance();

    //释放单实例，进程退出时调用
    static void deleteInstance();

	//返回所有的IP
	QVariantList getIP(){return m_ips;}
	
	//获取XML文件
	bool initalize();
	
    // 打印实例地址
    void Print();

private:
    // 将其构造和析构成为私有的, 禁止外部构造和析构
    SingleInstance();
    ~SingleInstance();

    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
    SingleInstance(const SingleInstance &signal);
    const SingleInstance &operator=(const SingleInstance &signal);

    //解析xml中的内容
    void parseIP(const QDomNode &root);

private:
    // 唯一单实例对象指针
    static SingleInstance *m_SingleInstance;
    static std::mutex m_Mutex;
    //存储IP
    QVariantList m_ips;
};

源文件：

//初始化静态成员变量
SingleInstance *SingleInstance::m_SingleInstance = nullptr;
std::mutex SingleInstance::m_Mutex;

// 注意：不能返回指针的引用，否则存在外部被修改的风险！
SingleInstance * SingleInstance::GetInstance()
{

    //  这里使用了两个 if 判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，
    //  避免每次调用 GetInstance的方法都加锁，锁的开销毕竟还是有点大的。
    if (m_SingleInstance == nullptr) 
    {
        std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
        if (m_SingleInstance == nullptr)
        {
            volatile auto temp = new (std::nothrow) SingleInstance();
            m_SingleInstance = temp;
        }
    }

    return m_SingleInstance;
}

void SingleInstance::deleteInstance()
{
    std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
    if (m_SingleInstance)
    {
        delete m_SingleInstance;
        m_SingleInstance = nullptr;
    }
}

bool SingleInstance::initalize()
{
	QString path("目录");
	QFile file(path);
	if(file.exists())
	{
		if(file.open(QIODevice::ReadOnly | QIODevice::Truncate))
		{
			QString error;
			QDomDocument document;
			document.setContent(&file, &error);
			file.close();
			if(document.isNull())
			{
				qDebug() << QString("文件格式异常:1%").arg(error);
				return false;
			}
			QDomNode root = document.firstChild();
			parseIP(root);
		}else{
			qDebug() << QString("%1:文件不存在,:2%").arg(path).arg(file.errorString());
		}
	}else{
		qDebug() QString("%1:文件不存在!").arg(path);
		return false;
	}
	return !m_ips.isEmpty();
}

void SingleInstance::Print()
{
	std::cout << "我的实例内存地址是:" << this << std::endl;
}

SingleInstance::SingleInstance()
{
    std::cout << "构造函数" << std::endl;
}

SingleInstance::~SingleInstance()
{
    std::cout << "析构函数" << std::endl;
    deleteInstance();
}

void SingleInstance::parseIP(const QDomNode &root)
{
	QDomNode startnode = root.nextSibling();
	QDomNode node = startnode.firstChild();
	while(!node.isNull())
	{
		QVariantMap ips;
		ips.clear();
		QDomElement element = node.toElement();
		ips.insert("ip", element.attribute("ip"));
		ips.insert("port", element.attribute("port"));
		ips.insert("multiip", element.attribute("multiip"));
	}
	
}

main.cpp

if(Singleton::GetInstance()->initalize())
{
...
}

2.2饿汉式

头文件

// 饿汉实现 /

class Singleton
{
public:
    // 获取单实例
    static Singleton* GetInstance();

    // 释放单实例，进程退出时调用
    static void deleteInstance();
	
	//返回所有的IP
	QVariantList getIP(){return m_ips;}
	
	//获取XML文件
	bool initalize();
    
    // 打印实例地址
    void Print();

private:
    // 将其构造和析构成为私有的, 禁止外部构造和析构
    Singleton();
    ~Singleton();

    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
    Singleton(const Singleton &signal);
    const Singleton &operator=(const Singleton &signal);
    
    //解析xml中的内容
    void parseIP(const QDomNode &root);

private:
    // 唯一单实例对象指针
    static Singleton *g_pSingleton;
    
    //存储IP
    QVariantList m_ips;
};

源文件：

// 代码一运行就初始化创建实例 ，本身就线程安全
Singleton* Singleton::g_pSingleton = new (std::nothrow) Singleton();

Singleton* Singleton::GetInstance()
{
    return g_pSingleton;
}

void Singleton::deleteInstance()
{
    if (g_pSingleton)
    {
        delete g_pSingleton;
        g_pSingleton = nullptr;
    }
}

bool SingleInstance::initalize()
{
	QString path("目录");
	QFile file(path);
	if(file.exists())
	{
		if(file.open(QIODevice::ReadOnly | QIODevice::Truncate))
		{
			QString error;
			QDomDocument document;
			document.setContent(&file, &error);
			file.close();
			if(document.isNull())
			{
				qDebug() << QString("文件格式异常:1%").arg(error);
				return false;
			}
			QDomNode root = document.firstChild();
			parseIP(root);
		}else{
			qDebug() << QString("%1:文件不存在,:2%").arg(path).arg(file.errorString());
		}
	}else{
		qDebug() QString("%1:文件不存在!").arg(path);
		return false;
	}
	return !m_ips.isEmpty();
}

void Singleton::Print()
{
    std::cout << "我的实例内存地址是:" << this << std::endl;
}

Singleton::Singleton()
{
    std::cout << "构造函数" << std::endl;
}

Singleton::~Singleton()
{
    std::cout << "析构函数" << std::endl;
    deleteInstance();
}

void SingleInstance::parseIP(const QDomNode &root)
{
	QDomNode startnode = root.nextSibling();
	QDomNode node = startnode.firstChild();
	while(!node.isNull())
	{
		QVariantMap ips;
		ips.clear();
		QDomElement element = node.toElement();
		ips.insert("ip", element.attribute("ip"));
		ips.insert("port", element.attribute("port"));
		ips.insert("multiip", element.attribute("multiip"));
	}
	
}

main.cpp

if(Singleton::GetInstance()->initalize())
{
...
}

xml说明

<?xml version="1.0" encoding="utf-8"?>XML声明是XML文档的第一句
<ips>
<ip ip="xxx" port="xxx" multiip="xxx"/>
</ips>