【设计模式】03：单例模式
单例模式
OVERVIOW
- 单例模式
-
-
- 1.单例模式实现
- 2.饿汉与懒汉
-
- （1）饿汉模式
- （2）懒汉模式
- 3.懒汉线程安全1
-
- （1）引入互斥锁
- （2）引入双重检查锁定
- （3）引入原子变量
- 4.懒汉线程安全2
-
- （1）设置局部静态对象
- 5.简单案例运用
-
- （1）任务队列简单实现
- （2）用户登录
-
项目全局范围内，某个类的实例有且仅有一个，通过这个实例向其他模块提供数据的全局访问，这种模式就叫单例模式。
单例模式的典型应用就是任务队列。使用单例模式来替代全局变量（对全局变量进行管理），直接使用全局变量会破坏类的封装（全局变量随意读写），通过单例模式的类提供的成员函数进行访问。
单例模式优点：
- 提高性能：避免频繁的创建销毁对象，提高性能，
- 节省内存空间：在内存中只有一个对象，节省内存空间，
- 避免多重占用：避免对共享资源的多重占用，
- 全局访问：可全局访问，利用单例模式避免全局变量的出现
单例模式缺点：
-
扩展困难：单例模式中没有抽象层，因此扩展困难，
-
不适用于变化的对象：如果同类型的对象总是要在不同的用例场景发生变化，单例就会引起数据错误，不能保存状态。
-
职责过重：违背了单一职责原则
-
负面问题：
为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多，而出现连接池溢出。
如果实例化的单例对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。
单利模式使用场景：
- 需要频繁实例化然后销毁的对象
- 创建对象耗时过多or消耗资源过多，但又经常使用到的对象，
- 有状态的工具类对象，
- 频繁访问数据库或文件的对象，
- 要求只有一个对象的场景
1.单例模式实现
如果使用单例模式，首先要保证这个类的实例有且仅有一个。因此就必须采取一些操作，涉及一个类多对象操作的函数有以下几个：
- 构造函数：创建一个新的对象
- 拷贝构造函数：根据已有对象拷贝出一个新的对象
- 拷贝赋值操作符重载函数：两个对象之间的赋值
为了把一个类可以实例化多个对象的路堵死，需要对以上几个函数做如下处理：
- 构造函数私有化，在类内部只调用一次这是可控的。
- 由于类外部不能使用构造函数，所以在类内部创建的唯一的对象必须是静态的，这样就可以通过类名来访问了，为了不破坏类的封装把这个静态对象设置为私有。
- 在类中只有它的静态成员函数才能访问其静态成员变量，所以给这个单例类提供一个静态函数用于得到这个静态的单例对象。
- 拷贝构造函数私有化或者禁用（使用 = delete）
- 拷贝赋值操作符重载函数私有化或者禁用（从单例的语义上讲该函数已经毫无意义，所以在类中不再提供这样一个函数，故将它也一并处理）
单例模式就是给类创建一个唯一的实例对象，UML类图如下：
#include以上为单例模式中的饿汉模式，在定义单例类的时候就将类对应的单例对象一并创建出来了。
2.饿汉与懒汉
在实现一个单例模式的类的时候，有两种处理模式：
- 饿汉模式：在将单例类定义出来后实例就已经存在了，饿汉模式没有线程安全问题
- 懒汉模式：在使用单例对象的时候才会去创建单例对象的实例（节省内存空间），懒汉模式存在线程安全问题（多个线程同时访问单例的实例）
（1）饿汉模式
- 多个线程在访问单例对象时，没有线程安全问题，单例对象已经存在，不会出现多个线程创建出多个单例对象的情况。
- 多线程拿到单例对象后，在访问单例对象内部的数据时，有线程安全问题（多线程共享资源），
//饿汉模式
class TaskQueue {
public:
TaskQueue(const TaskQueue &t) = delete;
TaskQueue& operator=(const TaskQueue &t) = delete;
static TaskQueue *getInstance() { return m_taskq; }
void printTest() { cout << "i am a public method of a singleton class" << endl; }
private:
TaskQueue() = default;
static TaskQueue *m_taskq;
};
TaskQueue* TaskQueue::m_taskq = new TaskQueue;
//饿汉模式
class TaskQueue {
public:
TaskQueue(const TaskQueue &t) = delete;
TaskQueue& operator=(const TaskQueue &t) = delete;
static TaskQueue *getInstance() { return &m_taskq; }
void printTest() { cout << "i am a public method of a singleton class" << endl; }
private:
TaskQueue() = default;
static TaskQueue m_taskq;//已经创建对象
};
TaskQueue* TaskQueue::m_taskq;//改为对象声明
（2）懒汉模式
//懒汉模式
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 printTest() { cout << "i am a public method of a singleton class" << endl; }
private:
TaskQueue() = default;
static TaskQueue *m_taskq;
};
TaskQueue* TaskQueue::m_taskq = nullptr;
3.懒汉线程安全1
在单例模式中饿汉模式下，针对在多线程中可能存在的线程安全问题（创建多个实例），进行问题修改：
（1）引入互斥锁
在多线程环境下，有可能的情况是：多个线程同时进入到getInstance()方法中的if语句判断中，这时对象就可能被同时创建多个，
//懒汉模式 引入互斥锁
class TaskQueue {
public:
TaskQueue(const TaskQueue &t) = delete;
TaskQueue& operator=(const TaskQueue &t) = delete;
static TaskQueue *getInstance() {
m_mutex.lock();
if (m_taskq == nullptr) m_taskq = new TaskQueue;
m_mutex.unlock();
return m_taskq;
}
void printTest() { cout << "i am a public method of a singleton class" << endl; }
private:
TaskQueue() = default;
static TaskQueue *m_taskq;
static mutex m_mutex;
};
mutex TaskQueue::m_mutex;
TaskQueue* TaskQueue::m_taskq = nullptr;
使用互斥锁对new操作创建实例时进行加锁操作，防止同时创建多个实例，但是程序执行的效率太低（多线程访问单例对象时都是顺序访问）
（2）引入双重检查锁定
双重检查锁定，只有第一次访问时是顺序执行的，在TaskQueue被实例化出来之后，其他线程再去访问单例对象就是并行的了（不会进入if内）。
//懒汉模式 引入双重检查锁定
class TaskQueue {
public:
TaskQueue(const TaskQueue &t) = delete;
TaskQueue& operator=(const TaskQueue &t) = delete;
static TaskQueue *getInstance() {
//双重检查锁定
if (m_taskq == nullptr) {
m_mutex.lock();
if (m_taskq == nullptr) m_taskq = new TaskQueue;
m_mutex.unlock();
}
return m_taskq;
}
void printTest() { cout << "i am a public method of a singleton class" << endl; }
private:
TaskQueue() = default;
static TaskQueue *m_taskq;
static mutex m_mutex;
};
mutex TaskQueue::m_mutex;
TaskQueue* TaskQueue::m_taskq = nullptr;
（3）引入原子变量
通过引入双重检查锁定的方式，解决了在懒汉模式下多线程访问单例对象时，出现的线程安全问题，
从表面上观察引入双重检查锁定的方式是十分完美的，但是从底层上依旧存在漏洞：
-
对于
m_taskq = new TaskQueue;操作，其对应的机器指令并不是一条，而有三条（对于计算机来说代码都是二进制指令/机器指令），step1：创建一块内存（没有数据） step2：创建 TaskQueue 类型的对象，并将数据写入到对象中 step3：为 m_taskq 对象指针初始化，将有效的内存地址传递给 m_taskq 对象指针 -
在实际的执行过程中，
m_taskq = new TaskQueue;对应的机器指令可能会被重新排序，成为step1：创建一块内存（没有数据） step3：为 m_taskq 对象指针初始化，将有效的内存地址传递给 m_taskq 对象指针 step2：创建 TaskQueue 类型的对象，并将数据写入到对象中 -
如果线程A执行完成前两步之后失去CPU时间片被挂起，此时线程B在进行指针判断时，发现指针
m_taskq不为空（但该指针指向内存没有被初始化），导致线程B使用了一个没有被初始化的队列对象，就会出现问题（出现问题是概率性的） -
在C++11中引入原子变量 atomic，在底层控制机器指令的执行顺序，可以实现一种更加安全的懒汉模式，代码如下：
使用原子变量
atomic的store()方法来存储单例对象，使用load()方法来加载单例对象，在原子变量中这两个函数在处理指令的时候，默认的原子顺序是 memory_order_seq_cst 顺序原子操作，
使用顺序约束原子操作库，整个函数的执行都将保证顺序执行，并且不会出现数据竞态 data races，
缺点：使用这种方法实现的懒汉模式的单例执行效率更低一些，
对代码进行以下修改：
-
通过原子变量将类的实例对象保存起来（m_taskq 指针指向的内存）
-
类外初始化 指针指向为nullptr
-
对 getInstance 方法进行相关的修改操作
多线层在调用 getInstance 方法时 需要从原子变量中加载任务队列的实例
抢到互斥锁的线程将继续向下执行 创建实例对象
-
//懒汉模式 引入原子变量
class TaskQueue {
public:
TaskQueue(const TaskQueue &t) = delete;
TaskQueue& operator=(const TaskQueue &t) = delete;
static TaskQueue *getInstance() {
TaskQueue* taskq = m_taskq.load();
if (taskq == nullptr) {
m_mutex.lock();
taskq = m_taskq.load();
if (taskq == nullptr) {
taskq = new TaskQueue;
m_taskq.store(taskq);
}
m_mutex.unlock();
}
return m_taskq.load();
}
void printTest() { cout << "i am a public method of a singleton class" << endl; }
private:
TaskQueue() = default;
// static TaskQueue *m_taskq;
static atomic<TaskQueue*> m_taskq;
static mutex m_mutex;
};
mutex TaskQueue::m_mutex;
atomic<TaskQueue*> TaskQueue::m_taskq;
// TaskQueue* TaskQueue::m_taskq = nullptr;
4.懒汉线程安全2
在懒汉模式线程安全问题中，除了可以通过引入双重检查锁定来解决线程安全问题，还可以使用局部静态对象处理线程安全问题，
（1）设置局部静态对象
使用静态的局部对象解决线程安全问题，要求编译器必修支持C++11标准，
- 在
getInstance()局部函数中定义一个静态局部对象static TaskQueue taskq;（调用无参构造初始化） - 在C++11标准中规定，如果指令逻辑进入一个未被初始化的声明变量，所有并发执行应当等待该变量完成初始化，
注：使用静态的局部对象没有线程安全问题，已经由C++11标准中的编译器解决，未被初始化的变量，必须等待其完成初始化才能并发执行，
step1：创建一块内存（没有数据）
step2：创建 TaskQueue 类型的对象，并将数据写入到对象中（完成初始化操作）
step3：为 m_taskq 对象指针初始化，将有效的内存地址传递给 m_taskq 对象指针
// 懒汉模式 静态局部对象
class TaskQueue {
public:
TaskQueue(const TaskQueue &t) = delete;
TaskQueue& operator=(const TaskQueue &t) = delete;
static TaskQueue* getInstance() {
static TaskQueue taskq;
return &taskq;
}
void printTest() { cout << "i am a public method of a singleton class" << endl; }
private:
TaskQueue() = default;
};
5.简单案例运用
（1）任务队列简单实现
-
多线程拿到单例对象后，在访问单例对象内部的数据时，有线程安全问题（多线程共享资源），使用互斥锁保护多线程中共享的资源，
-
C++11中给互斥锁加/解锁有两种方式，
方法1：调用mutex对象的
unlock();lock();方法方法2：使用lock_gurd自动管理加/解锁
lock_guardlocker(m_mutex); 使用
lock_gurd可以有效的避免死锁的问题，自动加/解锁
// 饿汉模式
class TaskQueue {
public:
TaskQueue(const TaskQueue &t) = delete;
TaskQueue& operator=(const TaskQueue &t) = delete;
static TaskQueue *getInstance() { return m_taskq; }
void printTest() { cout << "i am a public method of a singleton class" << endl; }
// 判断任务队列是否为空
bool isEmpty() {
lock_guard<mutex> locker(m_mutex);
return m_data.empty();
}
// 添加任务
void addTask(int node) {
lock_guard<mutex> locker(m_mutex);
m_data.push(node);
}
// 删除任务
bool removeTask() {
lock_guard<mutex> locker(m_mutex);
if (m_data.empty()) return false;
m_data.pop();
return true;
}
// 获取队头任务
int takeTask() {
lock_guard<mutex> locker(m_mutex);
if (m_data.empty()) return -1;
return m_data.front();
}
private:
TaskQueue() = default;
static TaskQueue *m_taskq;
// 任务队列
queue<int> m_data;
mutex m_mutex;
};
TaskQueue* TaskQueue::m_taskq = new TaskQueue;
#include 
（2）用户登录
当用户成功登录之后，用户名和密码就会被存储到内存中，可以创建一个单例类，将用户数据保存到单例对象中，
class Test {
public:
static Test* getInstance() { return &m_test; }
// m_user
void setUserName(QString name) {
// 多线程下需要加锁解锁（涉及写操作）
// lock();
m_user = name;
// unlock();
}
QString getUserName(){ return m_user; }
// m_passwd
// ....
// ....
// ....
private:
Test();
Test(const Test& t);
static Test* m_test;
// static Test m_test;
// 定义变量 -> 属于唯一的单例对象
QString m_user;
QString m_passwd;
QString m_ip;
QString m_port;
QString m_token;
}
Test* Test::m_test = new Test(); // 初始化
// Test Test::m_test;
tips：部分内容参考课程、书籍与网络等，题解、图示及代码内容根据老师课程、二次整理以及自己对知识的理解，进行整理和补充，仅供学习参考使用，不可商业化。