单例模式

我们知道，设计模式有着深邃的思想。现在来看看单例模式。

它的核心思想在于：有且仅有一个实例对象。

使用场景：某些类对象占用资源很大需要长时间驻留内存，多个模块共享的资源，需要频繁实例化然后访问的对象。比如：线程池。

实现方式：饿汉式（预先实例化，空间换时间），懒汉式（有请求时才实例化，时间换空间）

线程安全问题：饿汉式，由于预先创建了对象，所以就算多线程访问，也不会发生共享对象不同的情况；而懒汉式，存在实例化的过程，该过程如果不加锁，就会造成一个线程正在实例化对象（还未完成），然而另一个线程开始实例化的尴尬境地，造成实例化了多个对象的后果，违反了“只有一个实力”初衷。

---

 

看看如何实现👇

1. 饿汉式：实现简单，线程安全，无需加锁保证线程安全。

#include "pch.h"
#include <iostream>
using namespace std;

//单例模式：饿汉式
//1.实现单例，实例化对象
//2.不存在线程安全问题
class Singleton
{
public:
    ~Singleton();
    static Singleton * getInstance();
    static void destroy();
private:
    Singleton();//1.私有构造函数
    static Singleton* instance;//2.生成静态对象
    Singleton(const Singleton &s) = delete;//禁止实现拷贝构造
    Singleton* operator=(const Singleton &s) = delete;//禁止实现拷贝赋值
};

Singleton* Singleton::instance = new Singleton();//静态对象实例化
Singleton* Singleton::getInstance()//3.提供全局访问点
{
    return instance;
}
void Singleton::destroy()
{
    if (instance != nullptr)
    {
        delete instance;
        instance = nullptr;
        cout << "实例被析构" << endl;
    }
    else
        cout << "实例不存在" << endl;
}

Singleton::Singleton()
{
}

Singleton::~Singleton()
{
}

int main()
{
    Singleton *s1 = Singleton::getInstance();
    Singleton *s2 = Singleton::getInstance();
    if (s1 == s2)
        cout << "相同实例" << endl;
    s1->destroy();
    s2->destroy();
    return 0;
}

---

 

2. 懒汉式：需要时才实例化对象，存在线程安全问题，需要互斥锁，进而需要双重判断，提高效率。

初始版本：

#include <iostream>
using namespace std;

//单例模式：饿汉式
//1.实现单例，实例化对象
//2.不存在线程安全问题
class Singleton
{
public:
    ~Singleton();
    static Singleton * getInstance();
    static void destroy();
private:
    Singleton();//1.私有构造函数
    static Singleton* instance;//2.生成静态对象，先不实例化
    Singleton(const Singleton &s) = delete;//禁止实现拷贝构造
    Singleton* operator=(const Singleton &s) = delete;//禁止实现拷贝赋值
};

Singleton* Singleton::instance = nullptr;

Singleton* Singleton::getInstance()//3.提供全局访问点
{
    if (instance == nullptr)//还未实例化
    {
        instance = new Singleton();//进行实例化
        return instance;
    }
    return instance;//已经实例化返回存在的实例
}
void Singleton::destroy()
{
    if (instance != nullptr)
    {
        delete instance;
        instance = nullptr;
        cout << "实例被析构" << endl;
    }
    else
        cout << "实例不存在" << endl;
}

Singleton::Singleton()
{
    cout << "实例化" << endl;
}

Singleton::~Singleton()
{
}

int main()
{
    Singleton *s1 = Singleton::getInstance();
    Singleton *s2 = Singleton::getInstance();
    if (s1 == s2)
        cout << "相同实例" << endl;
    s1->destroy();
    s2->destroy();
    return 0;
}

（single1 和 single2 指向的是相同的实例instance，所以只会构造一次，地址相同；

---

上面👆的写法在多线程下并不安全，当两个线程同时运行到instance==nullptr时， 就会产生两个实例，这样就破坏了单例的原则---只有一个实例！

安全的单例模式

【1】首先我们会想到互斥锁，让关键代码成为临界区。👇

Singleton* Singleton::getIntance()
{
    mutex.lock();  //std::mutex
    if (instance == nullptr)
        instance = new Singleton();
    mutex.unlock();
    return instance;
}

【此种做法，在VS2017上调试，程序会因为：mutex destroyed while busy终止，通过下面的双重检查可以解决该问题】

这样做可以是的线程同步，但效率太低，我们试想，所有的线程都要等待解锁，其实只要第一个进入后对象产生， 其他的就可以直接返回instance了，不必要同步的等待开锁，浪费了时间。

怎么提高效率呢？👇

【2】double check双重检查

Singleton* Singleton::getIntance()
{
    if (instance == nullptr)//check1
    {
        imutex.lock();
        if (instance == nullptr)//check2
            instance = new Singleton();
        imutex.unlock();
    }
        
    return instance;
}

【源码】

#include "pch.h"
#include <iostream>
#include <mutex>
using namespace std;

//单例模式：饿汉式
//1.实现单例，实例化对象
//2.不存在线程安全问题
static mutex imutex;
class Singleton
{
public:
    ~Singleton();
    static Singleton * getInstance();
    static void destroy();
private:
    Singleton();//1.私有构造函数
    static Singleton* instance;//2.生成静态对象，先不实例化
    Singleton(const Singleton &s) = delete;//禁止实现拷贝构造
    Singleton* operator=(const Singleton &s) = delete;//禁止实现拷贝赋值
};

Singleton* Singleton::instance = nullptr;

Singleton* Singleton::getInstance()//3.提供全局访问点
{
    if (instance == nullptr)//
    {
        imutex.lock();//上锁
        if (instance == nullptr)//还未实例化
        {
            instance = new Singleton();//进行实例化
            imutex.unlock();//解锁
        }
    }
    return instance;//已经实例化返回存在的实例
}
void Singleton::destroy()
{
    if (instance != nullptr)
    {
        delete instance;
        instance = nullptr;
        cout << "实例被析构" << endl;
    }
    else
        cout << "实例不存在" << endl;
}

Singleton::Singleton()
{
    cout << "实例化" << endl;
}

Singleton::~Singleton()
{
}

int main()
{
    Singleton *s1 = Singleton::getInstance();
    Singleton *s2 = Singleton::getInstance();
    if (s1 == s2)
        cout << "相同实例" << endl;
    s1->destroy();
    s2->destroy();
    return 0;
}

从【1】我们可以看出，只要第一个线程进入临界区，其他的不需要进入，只要拿到实例返回就可以了，所以我们进行double check，第一个线程进来时为nullptr，进入实例化了instance；其他的线程运行到

if (instance == nullptr)//check1

时，instance ！= nullptr， 直接就返回。这样一来，大大提高了并发效率。

甚至我们可以从Tomcat Servlet 编译jsp生成的Java文件中见到它的身影！

 图看不清，看源码吧！

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

---

总结：

饿汉式，先加载，安全不加锁；

懒汉式，后加载，互斥双检查。

(￣_,￣ )一点都不押韵！

Java选手，参考这里