QT下单例模式

1 优点

1. 提供了对唯一实例的受控访问。
2. 由于在系统内存中只存在一个对象&＃xff0c;因此可以节约系统资源&＃xff0c;对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
3. 允许可变数目的实例。

2 缺点

1. 由于单利模式中没有抽象层&＃xff0c;因此单例类的扩展有很大的困难。
2. 单例类的职责过重&＃xff0c;在一定程度上违背了“单一职责原则”。
3. 滥用单例将带来一些负面问题&＃xff0c;如为了节省资源将数据库连接池对象设计为的单例类&＃xff0c;可能会导致共享连接池对象的程序过多而出现连接池溢出&＃xff1b;如果实例化的对象长时间不被利用&＃xff0c;系统会认为是垃圾而被回收&＃xff0c;这将导致对象状态的丢失。
4. 对象生命周期。单例模式没有提出对象的销毁&＃xff0c;在提供内存的管理的开发语言中&＃xff0c;只有单例模式对象自己才能将对象实例销毁&＃xff0c;因为只有它拥有对实例的引用。在各种开发语言中&＃xff0c;比如C&＃43;&＃43;&＃xff0c;其他类可以销毁对象实例&＃xff0c;但是这么做将导致单例类内部的指针指向不明。

3 代码示例

懒汉模式&＃xff1a;

class LogMannage
{
public:static LogMannage* instance(); //通过该接口访问void A();
private:static LogMannage *myLog; //单例模式定义的指针LogMannage(); //构造函数需要私有化&＃xff0c;不能被外部new~LogMannage();
};//懒汉模式&＃xff0c;静态变量初始化为空
LogMannage* LogMannage::myLog &＃61; NULL; LogMannage *LogMannage::instance() //接口返回类指针&＃xff0c;如果指针为空则需要创建对象再返回对象指针&＃xff08;第一次调用&＃xff09;
{if(myLog &＃61;&＃61; NULL) //如果要考虑到线程安全则需要添加互斥锁mPtr &＃61; new ThreadWifiBase();return mPtr;
}


饿汉模式&＃xff1a;

class LogMannage
{
public:static LogMannage* instance(); //通过该接口访问void A();
private:static LogMannage *myLog; //单例模式定义的指针LogMannage(); //构造函数需要私有化&＃xff0c;不能被外部new~LogMannage();
};//饿汉模式&＃xff0c;静态变量初始化的时候即创建对象
LogMannage* LogMannage::myLog &＃61; new LogMannage(); LogMannage *LogMannage::instance() //接口返回类指针就行&＃xff08;饿汉模式指针初始化时就创建了&＃xff09;
{return myLog;
}


4 单例模式实现原理

1.1 私有化构造函数&＃xff0c;使得外界不能通过new方式创建该单例对象。

1.2 创建静态对象指针。

1.1、1.2操作代码如下所示&＃xff1a;

class RaspiTemp
{
private:static RaspiTemp *instancePrt; //创建静态对象指针explicit RaspiTemp(); //私有化构造函数~RaspiTemp();
}


1.3 单例对象访问接口定义&＃xff1a;

需要定义为静态函数&＃xff0c;可供外部直接访问而不需要依据对象指针访问。代码如下&＃xff1a;

public&＃xff1a;static RaspiTemp* instance(); //定义


1.3 单例对象的创建

懒汉模式是在需要用的时候&＃xff0c;即首次访问时才创建单例对象&＃xff0c;所以首次访问相对比较慢。懒汉模式就好像一个懒人&＃xff08;狠人&＃xff09;&＃xff0c;一直懒得找对象&＃xff0c;在需要结婚的时候才去找对象&＃xff0c;有了对象后就结婚&＃xff1b;而对应的饿汉就是&＃xff0c;管他结婚不结婚&＃xff0c;先找个对象再说&＃xff0c;需要结婚的时候直接结就行了。

饿汉模式是在程序启动&＃xff0c;静态变量&＃xff08;1.2中单例对象类的静态指针&＃xff09;初始化的时候就创建单例对象。由于静态变量初始化在代码导入内存时候就初始化了&＃xff0c;即main函数运行之前就创建了单例对象&＃xff0c;所以不存在线程安全问题。

1.3.1 懒汉模式实现

代码如下&＃xff1a;

// .cpp文件中实现
RaspiTemp *RaspiTemp::instancePrt &＃61; NULL;
RaspiTemp*RaspiTemp::instance() //实现
{if(instancePrt&＃61;&＃61; NULL) instancePrt&＃61; new RaspiTemp(); //懒汉模式下对象创建&＃xff08;首次调用instance时创建&＃xff09;return instancePrt;
}


1.3.1 饿汉模式实现

代码如下&＃xff1a;

// .cpp文件中实现
RaspiTemp *RaspiTemp::instancePrt &＃61; new RaspiTemp(); //饿汉模式下对象创建&＃xff08;静态变量初始化时创建&＃xff09;
RaspiTemp*RaspiTemp::instance() //实现
{return instancePrt;
}


5 单例模式的线程安全实现

前面有说明&＃xff0c;饿汉模式在静态变量初始化的时候就实例化了单例对象&＃xff0c;所以不存在线程安全问题&＃xff0c;而且其访问接口中只有返回对象指针而没有创建对象的代码。但是单例模式对象的创建是在首次访问的时候&＃xff0c;如果两个线程同时访问的时候&＃xff0c;就可能造成单例对象被重复构建而导致内存浪费&＃xff08;对&＃xff01;仅仅内存浪费而已&＃xff09;&＃xff0c;解决此方法就是使用互斥锁。

为了理解&＃xff0c;还是使用之前例子说明一下&＃xff0c;结婚前才找对象&＃xff0c;其实就是相亲&＃xff0c;在你没相亲成功前你就是单身状态&＃xff0c;你可以同时相亲两个或多个妹子&＃xff08;帅哥&＃xff09;&＃xff0c;不巧结果全相中了&＃xff0c;这时候你的对象就有了多个&＃xff0c;而结婚的对象确只能一个&＃xff08;别问我为什么&＃xff0c;我也不知道&＃xff09;&＃xff0c;于是其他对象就被放弃在那里&＃xff1b;然后政府为了避免这种浪费可耻的现象&＃xff0c;于是规定你在同一时刻只能相亲一个对象&＃xff0c;这个对象相亲结束后才能相亲下一个&＃xff0c;这样就能解决问题了不是&＃xff0c;但是怎么做到呢&＃xff1f;这就是需要上锁&＃xff0c;首先判断指针是否为空&＃xff08;指向对象&＃xff09;&＃xff0c;如果为空就加锁&＃xff0c;然后再判断一次后再创建对象。

懒汉模式中代码修改如下&＃xff1a;

static QMutex staticMutexSend;
RaspiTemp *RaspiTemp::instance()
{if(instancePrt &＃61;&＃61; NULL) {staticMutexSend.lock(); //保证线程安全if(instancePrt &＃61;&＃61; NULL)instancePrt &＃61; new RaspiTemp ();staticMutexSend.unlock(); }return instancePrt ;
}


6 单例模式&＃43;独立子线程模式

多线程的实现&＃xff0c;qt有两种方式&＃xff0c;一种是继承Qthread类并重写run() 函数实现&＃xff1b;一种是继承QObject类&＃xff0c;使用QObject中的moveToThread() 函数实现。