定义:
确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例
示例一:皇帝与臣子
实现方式:
通过定义一个private的构造函数,避免被其他类new出来一个对象,而Emperor自己可以new一个对象出来,其他类对该类的访问都可以通过getInstance获得同一个对象
臣子叩拜唯一皇帝的过程类图7-1:
代码清单7-2:
////// ********** 示例一 ***************//
//Emperor
class Emperor
{
public:
static Emperor* getInstance()
{
return m_emperor;
}
static void say(){qDebug() << "I'm Emperor";}
private:
Emperor(){} //不希望产生第二个皇帝
private:
//初始化一个皇帝
static Emperor *m_emperor;
};
Emperor* Emperor::m_emperor = new Emperor();
//Minister
class Minister
{
public:
void visit()
{
Emperor* emperor = Emperor::getInstance();
for (int day = 0; day < 3; ++day)
{
emperor->say();
}
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Minister minister;
minister.visit();
return a.exec();
}
示例二:单例模式的通用类图7-2
单例模式通用 代码清单7-3:
//// ********** 7-3 单例模式通用代码(饿汉模式) ***************//
class Singleton
{
public:
static Singleton* getSingleton() //通过该方法获得实例对象
{
return m_singleton;
}
static void doSomething(){} //类中其他方法,尽量是static
private:
Singleton(){} //限制产生多个对象
private:
static Singleton *m_singleton;
};
Singleton* Singleton::m_singleton = new Singleton();
三、单例模式的应用
优点:
- 由于单例模式在内存中只有一个实例,减少了内存开支,特别是一个对象需要频繁地创建、销毁时,而且创建或销毁时性能又无法优化,单例模式的优势就非常明显
- 由于单例模式只生成一个实例,所以减少了系统的性能开销,当一个对象的产生需要比较多的资源时,如读取配置、产生其他依赖对象时,则可以通过在应用启动时直接产生一个单例对象,然后用用就驻留内存的方式来解决
- 单例模式可以避免对资源的多重占用。例如一个写文件动作,由于只有一个实例存在内存中,避免对同一个资源文件的同时写操作。
- 单例模式可以在系统何止全局的访问点,优化和共享资源访问。例如可以设计一个单例类,负责所有数据表的映射处理
缺点:
- 单例模式一般没有接口,扩展很困难,若要扩展,除了修改代码基本上没有第二种途径可以实现。单例模式为什么不能增加接口呢?因为接口对单例模式是没有任何意义的,它要求“自行实例化”,并且提供单一实例、接口或抽象类是不可能被实例化的。当然特殊情况下,单例模式可以实现接口、被继承等,需要再系统开发中根据环境判断
- 单例模式对测试是不利的。在并行开发环境中,如果单例模式没有完成,是不能进行测试的,没有接口也不能使用mock的方式虚拟一个对象
- 单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑,而不关心它是否是单例的,是不是要单例取决于环境,单例模式把“要单例”和业务逻辑融合在一个类中
四、单例模式的使用场景
在一个系统中,要求一个类有且仅有一个对象,如果出现多个对象就会出现“不良反应”,可以采用单例模式,具体的场景如下:
- 要求生成唯一序列号的环境
- 在整个项目中需要一个共享访问点或共享数据。例如一个Web页面上的计数器,可以不用把每次刷新都记录到数据库中,使用单例模式保持计数器的值,并确保是线程安全的
- 创建一个对象需要消耗的资源过多,如果要访问IO和数据库等资源
- 需要定义大量的静态常量和静态方法(如工具类)的环境,可以采用单例模式(当然,也可以直接声明为static的方式)
五、单例模式的注意事项
在高并发情况下,注意单例模式的线程同步问题。
单例模式有几种不同的实现方式,上面的例子不会出现产生多个实例的情况,但是如下代码清单所示的单例模式需要考虑线程同步。
不安全的单例 代码清单7-4:
////// ********** 7-4 线程不安全的单例 ***************//
class Singleton
{
public:
static Singleton* getSingleton()
{
if (m_singleton == nullptr)
{
m_singleton = new Singleton();
}
return m_singleton;
}
private:
Singleton(){}
private:
static Singleton* m_singleton;
};
Singleton* Singleton::m_singleton = nullptr;
分析:该单例模式在低并发的情况下尚不会出现问题,若系统压力增大,并发量增加时则可能在内存中出现多个实例,破坏了最初的预期。为什么会出现这种情况呢?如一个线程A执行到singleton = new Singleton(),但是还没有获得对象(对象初始化是需要时间的),第二个线程B也在执行,执行到(singleton == nullptr)判断,那么线程B获得判断条件也为真,于是继续运行下去,线程A和线程B都获得了一个对象,在内存中就出现了两个对象!
备注:
代码清单7-3经常被称为饿汉式单例
将代码清单7-4加入锁经常被称为懒汉式单例
六、单例模式的扩展
如果一个类可以产生多个对象,对象的数量不受限制,则非常容易实现,直接使用new关键字就可以。如果只需要一个对象,使用单例模式就可以。但如果要求一个类智能产生两三个对象呢?如何实现?
示例:多个皇帝,类图7-3:
代码清单7-5:
////// ********** 7-5 有上限的多例模式 ***************//
#include <QCoreApplication>
#include <QDebug>
#include <ctime>
using namespace std;
class Emperor
{
public:
static Emperor* getInstance()
{
srand(time(0));
int ran = rand()% (m_maxNumOfEmperor);
return m_emperorList.at(ran);
}
static void say()
{
srand(time(0));
int ran = rand()% (m_maxNumOfEmperor);
qDebug() << m_nameList.at(ran);
}
static void init()
{
for (int i = 0; i < m_maxNumOfEmperor; ++i)
{
Emperor("emperor:" + QString::number(i));
}
}
private:
Emperor(){}
Emperor(QString name)
{
Emperor *emperor = new Emperor();
m_emperorList.push_back(emperor);
m_nameList.push_back(name);
}
private:
static int m_maxNumOfEmperor; //定义最多能产生的实例数量
static int m_countNumOfEmperor; //当前序列号
static QStringList m_nameList; //名字,用QStringList容器来存储
static QList<Emperor*> m_emperorList; //定义一个列表,容纳所有实例
};
int Emperor::m_maxNumOfEmperor = 2;
int Emperor::m_countNumOfEmperor = 0;
QStringList Emperor::m_nameList;
QList<Emperor*> Emperor::m_emperorList;
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Emperor::init();
int ministerNum = 5;
for (int i = 0; i < ministerNum; ++i)
{
Emperor* emperor = Emperor::getInstance();
qDebug() << "minister" << i+1 << ":";
emperor->say();
}
return a.exec();
}
分析:在Emperor中使用了两个list分别存储实例和实例变量。当然,如果考虑到线程安全问题,可以使用vector代替。
这种需要产生固定数量对象的模式就叫做有上限的多例模式,它是单例模式的一种扩展,采用有上限的多例模式,我们可以在设计时决定在内存中有多少个实例,方便系统进行扩展,修正单例可能存在的性能问题,提供系统的响应速度。例如读取文件,我们可以在系统启动时完成初始化工作,在内存中启动固定数量的reader实例,然后再需要读取文件时就可以快速响应
参考文献《秦小波. 设计模式之禅》(第2版) (华章原创精品) (Kindle 位置 308-310). 机械工业出版社