单例模式（C++代码实现）

1、先来谈谈什么是单例模式

这个单例模式说白了就一个句话：我是皇帝我独苗

看看书上的定义：单例模式（Singleton Pattern）Ensure a class has only one instance, and provide a global point of access to it.（确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例）

使用场景：一个系统要求一个类只有且仅有一个对象，如果出现多个对象就会出现不良反应，可以采用单例模式

     要求生成唯一序列号

     在整个项目需要一个共享访问点或共享数据

     创建一个对象需要消耗的资源过多，如需要访问IO和数据库等资源

     需要大量定义静态常量和静态方法（如工具类）的环境，当然也可以直接定义为static

2、实现思路：既然只能有一个实例，那我这个类里的构造函数就不能被随便调用了，那我就把构造函数写成私有的，这样别人就不能调用了，接下来就该考虑我自己这个独苗该怎么产生了，定义里面说到自行实例化，并且提供给整个系统，那我就用一个static  实例化一个实例，然后返回这个static实例。

3、考虑的问题

一个实例，整个系统使用，那线程同步问题就必须要考虑了。

为了解决这个问题：懒汉模式、饿懒汉模式、Meyers Singleton(目前最推荐的C++单例写法)

4、代码实现

//Meyers Singleton(目前最推荐的C++单例写法)
#include <iostream>

using namespace std;

class Singleton
{
public:
    static Singleton& Instance()
    {
        static Singleton theSingleton;
        return theSingleton;
    }
    void doSomeThong();
private:
    Singleton();
    ~Singleton();
};

Singleton::Singleton()
{
}

Singleton::~Singleton()
{
}
void Singleton::doSomeThong()
{
    cout << "单例类" << endl;
    cout << "C++最推荐的单例类写法" << endl;
}

int main()
{
    Singleton::Instance().doSomeThong();
    return 0;
}

//懒汉模式：顾名思义，是一种典型的拖延（lazy）策略。当第一次要用单例类的时候，再产生实例
#include <iostream>

using namespace std;

class Singleton
{
public:
    ~Singleton();
    //提供单例类的访问方法
    static Singleton* getInstance();
    //提供删除方法
    static void deleteInstance();
    void doSomething();
protected:
    Singleton();//构造方法定义为protect
    static Singleton* theSingleton; //单例类对象指针

};

Singleton* Singleton::theSingleton = nullptr;//讲我们的单例对象指针初始化空

Singleton::Singleton()
{
}

Singleton::~Singleton()
{
}

Singleton* Singleton::getInstance()
{
    if (!theSingleton)
        theSingleton = new Singleton();
    return theSingleton;
}

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

void Singleton::doSomething()
{
    cout << "懒汉模式" << "
" << "单例模式" << endl;
}

int main()
{
    Singleton::getInstance()->doSomething();
    return 0;
}

 看这图很显然Singleton成为了一个单例类，但在这一块我没有解决线程安全问题，这个需要用到多线程的锁机制

//饿汉模式
//饿汉模式与懒汉模式相反，是程序一开始就生成唯一实例。这样就不用检查是否存在实例，而且也无需考虑产生实例时的线程安全。

#include <iostream>

using namespace std;

class Singleton {
public:
    ~Singleton();
    //提供单例对象访问
    static Singleton& getInstance();
    void doSomething();
protected:
    //构造函数声明为 保护方法
    Singleton();
    //单例对象指针
    static Singleton theSingleton;
};

//提供单例类对象访问
Singleton& Singleton::getInstance() {
    return theSingleton;
}

void Singleton::doSomething()
{
    cout << "饿懒汉模式" << "
" << "单例模式" << endl;
}

Singleton::Singleton()
{
}
Singleton::~Singleton()
{}

int main()
{
    Singleton::getInstance().doSomething();
    return 0;
}
//很不负责的把这段代码放在这

5、优点

    ①由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁创建销毁时。

    ②减少系统性能开销

    ③避免对资源的多重占用

    ④单例模式可以在系统设置全局访问点，优化和共享资源访问

6、缺点

     ①单例模式一般没有接口，很难扩展，扩展基本必须修改源代码

    ②对测试不友好，需要解决在并发中的问题

    ③单例模式与单一职责原则有冲突

参考书籍《设计模式之禅》