如何优雅地实现全局唯一？深入理解单例模式

一、什么是单例模式？

单例模式是一种创建型设计模式，旨在确保一个类只有一个实例，并为该实例提供全局访问点，从而避免全局变量的命名污染，并支持延迟初始化Wikipedia。

关键点:

私有构造函数（禁止外部new创建）
静态私有实例变量
静态公有获取方法

二、C++实现示例

c++ 复制代码

#include<iostream>
using namespace std;
#if 0
// 饿汉模式 -> 定义类的时候创建单例对象
// 在多线程的场景下没用线程安全问题
// 线程安全：多线程同时访问单例模式
// 定义一个单例模式的任务队列
class TaskQueue
{
public:
    TaskQueue(const TaskQueue & t) = delete;
    TaskQueue& operator =(const TaskQueue& t) = delete;
    static TaskQueue *getInstance()
    {
        return m_taskQ;
    }
    void print()
    {
        cout<<"我是单例对象的一个成员函数..."<<endl;
    }
private:
    TaskQueue() = default;
    // 只能通过类名访问静态成员属性或方法
    static TaskQueue* m_taskQ;
};
TaskQueue* TaskQueue::m_taskQ = new TaskQueue;
#endif

#if 1
// 懒汉模式 -> 什么时候使用这个单例，再使用的时候再去创建对应的实例
// 在多线程的场景下可能存在线程安全问题
// 加互斥锁，让线程依次访问单例对象
// 比较节省内存空间
class TaskQueue
{
public:
    TaskQueue(const TaskQueue & t) = delete;
    TaskQueue& operator =(const TaskQueue& t) = delete;
    static TaskQueue *getInstance()
    {
        if(m_taskQ == nullptr)
        {
            m_taskQ = new TaskQueue;
        }
        return m_taskQ;
    }
    void print()
    {
        cout<<"我是单例对象的一个成员函数..."<<endl;
    }
private:
    TaskQueue() = default;
    //只能通过类名访问静态成员属性或方法
    static TaskQueue* m_taskQ;
};
TaskQueue* TaskQueue::m_taskQ = nullptr;
#endif
int main()
{
    TaskQueue* taskQ = TaskQueue::getInstance();
    taskQ->print();
    return 0;
}

懒汉模式使用双重检查锁定解决线程安全问题

问题原因：

多线程调用懒汉模式getInstance() ，就会创建出多个TaskQueue的实例，违背单例模式的定义，所谓的单例就是只能有唯一的一个单例对象

解决方法：

1、互斥锁解决线程安全问题

互斥锁：避免同时访问，按顺序依次访问

使用原子变量解决双重检查的问题：

c++ 复制代码

//互斥锁头文件
#include<mutex>
...
   mutex TaskQueue::m_mutex;
...
   static mutex m_mutex;
...
   static TaskQueue *getInstance()
    {
        if(m_taskQ == nullptr)//第一次检查
        {
            //进行加锁操作
            m_mutex.lock();
            if(m_taskQ == nullptr)//第二次检查
            {
                m_taskQ = new TaskQueue;
            }
            //进行解锁操作 *注意*一个程序加锁之后一定要解锁，否则导致死锁
            m_mutex.unlock();
        }
        return m_taskQ;
    } 
...

使用原子变量解决双重检查的问题

c++ 复制代码

//原子变量头文件
#include<atomic>
...
   atomic<TaskQueue*> TaskQueue::m_taskQ = nullptr; //初始化
...
   static atomic<TaskQueue*>m_taskQ;
...
   static TaskQueue *getInstance()
    {
        TaskQueue* task = m_taskQ.load();
        if(task == nullptr)
        {
            m_mutex.lock();
            task = m_taskQ.load();//通过原子变量加载实例化指针
            if(task == nullptr)
            {
                task = new TaskQueue;
                m_taskQ.store(task);
            }
            m_mutex.unlock();
        }
        return task;
    } 
...

2、局部静态对象解决线程安全问题

c++ 复制代码

// 使用静态的局部对象解决线程安全问题 ->编译器支持C++11
...
class TaskQueue
{
public:
    TaskQueue(const TaskQueue & t) = delete;
    TaskQueue& operator =(const TaskQueue& t) = delete;
    static TaskQueue *getInstance()
    {
        static TaskQueue task;

        return &task;
    }
    void print()
    {
        cout<<"我是单例对象的一个成员函数..."<<endl;
    }
private:
    TaskQueue() = default;

};
...