设计模式 c++版（1）——单例模式

定义：

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例

---

示例一：单例模式（通用版）

1. 类图7-2

 

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();

 

示例二：皇帝与臣子

1. 类图7-1：

 

2. 类图说明：

通过定义一个private的构造函数，避免被其他类new出来一个对象，而Emperor自己可以new一个对象出来，其他类对该类的访问都可以通过getInstance获得同一个对象

 

3. 代码清单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();
}

 

三、单例模式的应用

优点：

1. 由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显
2. 由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用用就驻留内存的方式来解决
3. 单例模式可以避免对资源的多重占用。例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
4. 单例模式可以在系统何止全局的访问点，优化和共享资源访问。例如可以设计一个单例类，负责所有数据表的映射处理

缺点：

1. 单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。单例模式为什么不能增加接口呢？因为接口对单例模式是没有任何意义的，它要求“自行实例化”，并且提供单一实例、接口或抽象类是不可能被实例化的。当然特殊情况下，单例模式可以实现接口、被继承等，需要再系统开发中根据环境判断
2. 单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能使用mock的方式虚拟一个对象
3. 单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中

 

四、单例模式的使用场景

在一个系统中，要求一个类有且仅有一个对象，如果出现多个对象就会出现“不良反应”，可以采用单例模式，具体的场景如下：

1. 要求生成唯一序列号的环境
2. 在整个项目中需要一个共享访问点或共享数据。例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的
3. 创建一个对象需要消耗的资源过多，如果要访问IO和数据库等资源
4. 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为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关键字就可以。如果只需要一个对象，使用单例模式就可以。但如果要求一个类智能产生两三个对象呢？如何实现？

 

示例三：多个皇帝

1. 类图7-3：

 

2. 代码清单7-5:

//    **********  7-5 有上限的多例模式 ***************//


#include 
#include 
#include 
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 m_emperorList;       //定义一个列表，容纳所有实例

};

int Emperor::m_maxNumOfEmperor = 2;
int Emperor::m_countNumOfEmperor = 0;
QStringList Emperor::m_nameList;
QList 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版） (华章原创精品) 机械工业出版社