创建型--单例模式

什么是单例模式？

---

单例模式：一个类只允许创建一个实例对象。

# 单例模式的应用场景 ---- 1. 当一个类作用于全局时，可以把它设计为单例模式，避免了频繁的创建和销毁； 2. 一个班级只能有一个班主任（班主任类应该设计为单例模式）； 3. Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以对文件的处理必须通过唯一的实例来进行；文件的处理类应该设计为单例模式； 4. 一些设备管理器常常被设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件； 5. 要求生成唯一的***；***生成器应该被设计为单例模式；
# 单例模式的优缺点 ---- - 优点： - 在内存中只有一个实例，减少了内存开销，尤其是频繁的创建和销毁实例； - 避免资源的多重占用（比如写文件操作）； - 缺点： - 没有接口，不能继承，与单一职责原则冲突； - 一个类应该只关心内部逻辑，而不关心外面怎么样来实例化；

单例模式如何实现

---

实现单例模式时，主要注意两点：

• 构造函数是私有的， 禁止用户声明并定义实例；
• 该类只有一个实例，声明为 static 特征；
• 用户通过接口获取实例：使用 static 类成员函数，getInstance() 方法中需要使用同步锁 synchronized(Singleton class) 以防止多线程同时进入造成 instance 被多次实例化；
• 禁止赋值和拷贝；

有缺陷的懒汉模式

懒汉模式(Lazy-Initialization) 的方法是直到使用时才实例化对象，也就说直到调用 get_instance() 方法的时候才 new 一个单例的对象。好处是如果被调用就不会占用内存。

#include <iostream>
// version1:
// with problems below:
// 1. thread is not safe
// 2. memory leak

class Singleton{
private:
    /*构造函数私有化*/
    Singleton() { std::cout<<"constructor called!"<<std::endl; }
    
    /*禁止赋值和拷贝*/
    Singleton(Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    
    /*静态成员*/
    static Singleton* m_instance_ptr;
public:
    ~Singleton() { std::cout<<"destructor called!"<<std::endl; }

    /*通过接口获取实例*/
    static Singleton* get_instance() {
        if(m_instance_ptr==nullptr)  
            m_instance_ptr = new Singleton;
        return m_instance_ptr;
    }
    void use() const { std::cout << "in use" << std::endl; }
};

/*类静态成员初始化*/
Singleton* Singleton::m_instance_ptr = nullptr;

int main(){
    Singleton* instance = Singleton::get_instance();
    Singleton* instance_2 = Singleton::get_instance();
    return 0;
}

运行结果：

constructor called!

可以看到，获取了两次类的实例，却只有一次类的构造函数被调用，表明只生成了唯一实例，这是个最基础版本的单例实现，他有哪些问题呢？

1. 线程安全的问题：当多线程获取单例时有可能引发竞态条件：第一个线程在 if 中判断 m_instance_ptr 是空的，于是开始实例化单例; 同时第2个线程也尝试获取单例，这个时候判断 m_instance_ptr 还是空的，于是也开始实例化单例;这样就会实例化出两个对象,这就是线程安全问题的由来; 解决办法:加锁。
2. 内存泄漏. 注意到类中只负责 new 出对象，却没有负责 delete 对象，因此只有构造函数被调用，析构函数却没有被调用;因此会导致内存泄漏。解决办法： 使用共享指针;

因此，这里提供一个改进的，线程安全的、使用智能指针的实现。

改进的懒汉模式

#include <iostream>
#include <memory> // shared_ptr
#include <mutex> // mutex

// version 2:
// with problems below fixed:
// 1. thread is safe now
// 2. memory doesn't leak

class Singleton{
public:
    typedef std::shared_ptr<Singleton> Ptr;
    ~Singleton() { std::cout<<"destructor called!"<<std::endl; }
    /*禁止复制和拷贝*/
    Singleton(Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    
    static Ptr get_instance() {
        // "double checked lock"
        if(m_instance_ptr == nullptr){
            std::lock_guard<std::mutex> lk(m_mutex); // 加锁
            if(m_instance_ptr == nullptr) {
              m_instance_ptr = std::shared_ptr<Singleton>(new Singleton);
            }
        }
        return m_instance_ptr;
    }


private:
    Singleton() { std::cout<<"constructor called!"<<std::endl; }
    /*静态成员*/
    static Ptr m_instance_ptr;
    static std::mutex m_mutex;
};

// initialization static variables out of class
Singleton::Ptr Singleton::m_instance_ptr = nullptr;
std::mutex Singleton::m_mutex;

int main(){
    Singleton::Ptr instance = Singleton::get_instance();
    Singleton::Ptr instance2 = Singleton::get_instance();
    return 0;
}

运行结果如下，发现确实只构造了一次实例，并且发生了析构

constructor called!
destructor called!

shared_ptr 和 mutex 都是 C++11 的标准，以上这种方法的优点是：

• 基于 shared_ptr, 用了 C++ 比较倡导的 RAII 思想，用对象管理资源。当 shared_ptr 析构的时候，new 出来的对象也会被 delete 掉。以此避免内存泄漏。
• 加了锁，使用互斥量来达到线程安全。这里使用了两个 if 判断语句的技术称为 双检锁；好处是，只有判断指针为空的时候才加锁，避免每次调用 get_instance 的方法都加锁，锁的开销毕竟还是有点大的。

不足之处在于： 使用智能指针会要求用户也得使用智能指针，非必要不应该提出这种约束; 使用锁也有开销; 同时代码量也增多了，实现上我们希望越简单越好。
还有更加严重的问题，在某些平台（与编译器和指令集架构有关），双检锁会失效！具体可以看这篇文章，解释了为什么会发生这样的事情。

推荐的懒汉式单例(magic static )：局部静态变量

include <iostream>

class Singleton
{
public:
    ~Singleton() { std::cout<<"destructor called!"<<std::endl; }
    
    /*禁止复制和拷贝*/
    Singleton(const Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    
    /*静态成员属性*/
    static Singleton& get_instance() {
        static Singleton instance;
        return instance;
    }
private:
    Singleton() { std::cout<<"constructor called!"<<std::endl; }
};

int main(int argc, char *argv[])
{
    Singleton& instance_1 = Singleton::get_instance();
    Singleton& instance_2 = Singleton::get_instance();
    return 0;
}

运行结果如下：

constructor called!
destructor called!

这种方法又叫做 Meyers’ SingletonMeyer’s 的单例， 是著名的写出《Effective C++》系列书籍的作者 Meyers 提出的。所用到的特性是在 C++11 标准中的 Magic Static 特性：

If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.
如果当变量在初始化的时候，并发同时进入声明语句，并发线程将会阻塞等待初始化结束。

这样保证了并发线程在获取静态局部变量的时候一定是初始化过的，所以具有线程安全性。
C++ 静态变量的生存期是从声明到程序结束，这也是一种懒汉式。
这是最推荐的一种单例实现方式：

• 通过局部静态变量的特性保证了线程安全 (C++11);
• 不需要使用共享指针，代码简洁；
• 注意在使用的时候需要声明单例的引用 Single& 才能获取对象。

另外网上有人的实现返回指针而不是返回引用：

static Singleton* get_instance() {
    static Singleton instance;
    return &instance;
}

这样做并不好，理由主要是无法避免用户使用 delete instance 导致对象被提前销毁。还是建议大家使用返回引用的方式。

源码链接在这里;

参考资料

---

1. 参考网络资料，最源出处已经不可考，非常感谢；