创建型模式--1.单例模式【巴基速递】

1. 巴基的订单

在海贼世界中，巴基速递是巴基依靠手下强大的越狱犯兵力，组建的集团海贼派遣公司，它的主要业务是向世界有需要的地方输送雇佣兵（其实是不干好事儿）。

在这里插入图片描述

自从从特拉法尔加罗和路飞同盟击败了堂吉诃德家族 ，战争的市场对雇佣兵的依赖越来越大。订单便源源不断的来了。此时我们来分析一个问题：巴基是怎么接单并且派单的呢？

简单来说，巴基肯定是有一个账本用于记录下单者信息，下单者的需求以及下单的时间，然后根据下单的先后顺序选择合适的人手进行派单。从程序猿的视角可以这样认为，这个账本其实就相当于一个任务队列：

  • 有一定的容量，可以存储任务
  • 按照下单的先后顺序存储并处理任务 – 典型的队列特性：先进先出

对于巴基来说把所有的订单全部记录到一个账本上就够了，如果将其平移到项目中，也就意味着应用程序在运行过程中存储任务的任务队列一个足矣，弄太多反而冗余，不太好处理了。

在一个项目中，全局范围内，某个类的实例有且仅有一个，通过这个唯一实例向其他模块提供数据的全局访问，这种模式就叫单例模式。单例模式的典型应用就是任务队列。

在这里插入图片描述

2. 独生子女

如果使用单例模式，首先要保证这个类的实例有且仅有一个，也就是说这个对象是独生子女，如果我们实施计划生育只生一个孩子，不需要也不能给再他增加兄弟姐妹。因此，就必须采取一系列的防护措施。对于类来说以上描述同样适用。涉及一个类多对象操作的函数有以下几个：

  • 构造函数：创建一个新的对象
  • 拷贝构造函数：根据已有对象拷贝出一个新的对象
  • 拷贝赋值操作符重载函数：两个对象之间的赋值

为了把一个类可以实例化多个对象的路堵死，可以做如下处理：

  1. 构造函数私有化，在类内部只调用一次，这个是可控的。
  • 由于使用者在类外部不能使用构造函数，所以在类内部创建的这个唯一的对象必须是静态的，这样就可以通过类名来访问了，为了不破坏类的封装，我们都会把这个静态对象的访问权限设置为私有的。
  • 在类中只有它的静态成员函数才能访问其静态成员变量，所以可以给这个单例类提供一个静态函数用于得到这个静态的单例对象。

  1. 拷贝构造函数私有化或者禁用（使用 = delete）

  2. 拷贝赋值操作符重载函数私有化或者禁用（从单例的语义上讲这个函数已经毫无意义，所以在类中不再提供这样一个函数，故将它也一并处理一下。）

由于单例模式就是给类创建一个唯一的实例对象，所以它的UML类图是很简单的：
在这里插入图片描述

因此，定义一个单例模式的类的示例代码如下：

// 定义一个单例模式的类
class Singleton
{
public:// = delete 代表函数禁用, 也可以将其访问权限设置为私有Singleton(const Singleton& obj) = delete;Singleton& operator=(const Singleton& obj) = delete;static Singleton* getInstance();
private:Singleton() = default;static Singleton* m_obj;
};

在实现一个单例模式的类的时候，有两种处理模式：

  • 饿汉模式
  • 懒汉模式

3. 饿汉模式

饿汉模式就是在类加载的时候立刻进行实例化，这样就得到了一个唯一的可用对象。关于这个饿汉模式的类的定义如下:

// 饿汉模式
class TaskQueue
{
public:// = delete 代表函数禁用, 也可以将其访问权限设置为私有TaskQueue(const TaskQueue& obj) = delete;TaskQueue& operator=(const TaskQueue& obj) = delete;static TaskQueue* getInstance(){return m_taskQ;}
private:TaskQueue() = default;static TaskQueue* m_taskQ;
};
// 静态成员初始化放到类外部处理
TaskQueue* TaskQueue::m_taskQ = new TaskQueue;int main()
{TaskQueue* obj = TaskQueue::getInstance();
}

在第17行，定义这个单例类的时候，就把这个静态的单例对象创建出来了。当使用者通过getInstance()获取这个单例对象的时候，它已经被准备好了。

注意事项：类的静态成员变量在使用之前必须在类的外部进行初始化才能使用。

4. 懒汉模式

懒汉模式是在类加载的时候不去创建这个唯一的实例，而是在需要使用的时候再进行实例化。

4.1 懒汉模式类的定义

// 懒汉模式
class TaskQueue
{
public:// = delete 代表函数禁用, 也可以将其访问权限设置为私有TaskQueue(const TaskQueue& obj) = delete;TaskQueue& operator=(const TaskQueue& obj) = delete;static TaskQueue* getInstance(){if(m_taskQ == nullptr){m_taskQ = new TaskQueue;}return m_taskQ;}
private:TaskQueue() = default;static TaskQueue* m_taskQ;
};
TaskQueue* TaskQueue::m_taskQ = nullptr;

在调用getInstance()函数获取单例对象的时候，如果在单线程情况下是没有什么问题的，如果是多个线程，调用这个函数去访问单例对象就有问题了。假设有三个线程同时执行了getInstance()函数，在这个函数内部每个线程都会new出一个实例对象。此时，这个任务队列类的实例对象不是一个而是3个，很显然这与单例模式的定义是相悖的。

4.2 线程安全问题

双重检查锁定

对于饿汉模式是没有线程安全问题的，在这种模式下访问单例对象的时候，这个对象已经被创建出来了。要解决懒汉模式的线程安全问题，最常用的解决方案就是使用互斥锁。可以将创建单例对象的代码使用互斥锁锁住，处理代码如下：

class TaskQueue
{
public:// = delete 代表函数禁用, 也可以将其访问权限设置为私有TaskQueue(const TaskQueue& obj) = delete;TaskQueue& operator=(const TaskQueue& obj) = delete;static TaskQueue* getInstance(){m_mutex.lock();if (m_taskQ == nullptr){m_taskQ = new TaskQueue;}m_mutex.unlock();return m_taskQ;}
private:TaskQueue() = default;static TaskQueue* m_taskQ;static mutex m_mutex;
};
TaskQueue* TaskQueue::m_taskQ = nullptr;
mutex TaskQueue::m_mutex;

在上面代码的10~13 行这个代码块被互斥锁锁住了，也就意味着不论有多少个线程，同时执行这个代码块的线程只能是一个（相当于是严重限行了，在重负载情况下，可能导致响应缓慢）。我们可以将代码再优化一下：

class TaskQueue
{
public:// = delete 代表函数禁用, 也可以将其访问权限设置为私有TaskQueue(const TaskQueue& obj) = delete;TaskQueue& operator=(const TaskQueue& obj) = 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;}
private:TaskQueue() = default;static TaskQueue* m_taskQ;static mutex m_mutex;
};
TaskQueue* TaskQueue::m_taskQ = nullptr;
mutex TaskQueue::m_mutex;

改进的思路就是在加锁、解锁的代码块外层有添加了一个if判断（第9行），这样当任务队列的实例被创建出来之后，访问这个对象的线程就不会再执行加锁和解锁操作了（只要有了单例类的实例对象，限行就解除了），对于第一次创建单例对象的时候线程之间还是具有竞争关系，被互斥锁阻塞。上面这种通过两个嵌套的 if 来判断单例对象是否为空的操作就叫做双重检查锁定。

双重检查锁定的问题

假设有两个线程A、B，当线程A 执行到第 8 行时在线程A中 TaskQueue 实例对象 被创建，并赋值给 m_taskQ。

static TaskQueue* getInstance()
{if (m_taskQ == nullptr){m_mutex.lock();if (m_taskQ == nullptr){m_taskQ = new TaskQueue;}m_mutex.unlock();}return m_taskQ;
}

但是实际上 m_taskQ = new TaskQueue; 在执行过程中对应的机器指令可能会被重新排序。正常过程如下：

  • 第一步：分配内存用于保存 TaskQueue 对象。
  • 第二步：在分配的内存中构造一个 TaskQueue 对象（初始化内存）。
  • 第三步：使用 m_taskQ 指针指向分配的内存。

但是被重新排序以后执行顺序可能会变成这样：

  • 第一步：分配内存用于保存 TaskQueue 对象。
  • 第二步：使用 m_taskQ 指针指向分配的内存。
  • 第三步：在分配的内存中构造一个 TaskQueue 对象（初始化内存）。

这样重排序并不影响单线程的执行结果，但是在多线程中就会出问题。如果线程A按照第二种顺序执行机器指令，执行完前两步之后失去CPU时间片被挂起了，此时线程B在第3行处进行指针判断的时候m_taskQ 指针是不为空的，但这个指针指向的内存却没有被初始化，最后线程 B 使用了一个没有被初始化的队列对象就出问题了（出现这种情况是概率问题，需要反复的大量测试问题才可能会出现）。

在C++11中引入了原子变量atomic，通过原子变量可以实现一种更安全的懒汉模式的单例，代码如下：

class TaskQueue
{
public:// = delete 代表函数禁用, 也可以将其访问权限设置为私有TaskQueue(const TaskQueue& obj) = delete;TaskQueue& operator=(const TaskQueue& obj) = delete;static TaskQueue* getInstance(){TaskQueue* queue = m_taskQ.load();  if (queue == nullptr){// m_mutex.lock();  // 加锁: 方式1lock_guard<mutex> locker(m_mutex);  // 加锁: 方式2queue = m_taskQ.load();if (queue == nullptr){queue = new TaskQueue;m_taskQ.store(queue);}// m_mutex.unlock();}return queue;}void print(){cout << "hello, world!!!" << endl;}
private:TaskQueue() = default;static atomic<TaskQueue*> m_taskQ;static mutex m_mutex;
};
atomic<TaskQueue*> TaskQueue::m_taskQ;
mutex TaskQueue::m_mutex;int main()
{TaskQueue* queue = TaskQueue::getInstance();queue->print();return 0;
}

上面代码中使用原子变量atomic的store() 方法来存储单例对象，使用load() 方法来加载单例对象。在原子变量中这两个函数在处理指令的时候默认的原子顺序是memory_order_seq_cst（顺序原子操作 - sequentially consistent），使用顺序约束原子操作库，整个函数执行都将保证顺序执行，并且不会出现数据竞态（data races），不足之处就是使用这种方法实现的懒汉模式的单例执行效率更低一些。

静态局部对象

在实现懒汉模式的单例的时候，相较于双重检查锁定模式有一种更简单的实现方法并且不会出现线程安全问题，那就是使用静态局部局部对象，对应的代码实现如下：

class TaskQueue
{
public:// = delete 代表函数禁用, 也可以将其访问权限设置为私有TaskQueue(const TaskQueue& obj) = delete;TaskQueue& operator=(const TaskQueue& obj) = delete;static TaskQueue* getInstance(){static TaskQueue taskQ;return &taskQ;}void print(){cout << "hello, world!!!" << endl;}private:TaskQueue() = default;
};int main()
{TaskQueue* queue = TaskQueue::getInstance();queue->print();return 0;
}

在程序的第 9、10 行定义了一个静态局部队列对象，并且将这个对象作为了唯一的单例实例。使用这种方式之所以是线程安全的，是因为在C++11标准中有如下规定，并且这个操作是在编译时由编译器保证的：

如果指令逻辑进入一个未被初始化的声明变量，所有并发执行应当等待该变量完成初始化。

最后总结一下懒汉模式和饿汉模式的区别：

懒汉模式的缺点是在创建实例对象的时候有安全问题，但这样可以减少内存的浪费（如果用不到就不去申请内存了）。饿汉模式则相反，在我们不需要这个实例对象的时候，它已经被创建出来，占用了一块内存。对于现在的计算机而言，内存容量都是足够大的，这个缺陷可以被无视。

5. 替巴基写一个任务队列

作为程序猿的我们，如果想给巴基的账本升级成一个应用程序，首要任务就是设计一个单例模式的任务队列，那么就需要赋予这个类一些属性和方法：

  1. 属性：
    • 存储任务的容器，这个容器可以选择使用STL中的队列（queue)
    • 互斥锁，多线程访问的时候用于保护任务队列中的数据
  2. 方法：主要是对任务队列中的任务进行操作
    • 任务队列中任务是否为空
    • 往任务队列中添加一个任务
    • 从任务队列中取出一个任务
    • 从任务队列中删除一个任务

根据分析，就可以把这个饿汉模式的任务队列的单例类定义出来了：

#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
using namespace std;class TaskQueue
{
public:// = delete 代表函数禁用, 也可以将其访问权限设置为私有TaskQueue(const TaskQueue& obj) = delete;TaskQueue& operator=(const TaskQueue& obj) = delete;static TaskQueue* getInstance(){return &m_obj;}// 任务队列是否为空bool isEmpty(){lock_guard<mutex> locker(m_mutex);bool flag = m_taskQ.empty();return flag;}// 添加任务void addTask(int data){lock_guard<mutex> locker(m_mutex);m_taskQ.push(data);}// 取出一个任务int takeTask(){lock_guard<mutex> locker(m_mutex);if (!m_taskQ.empty()){return m_taskQ.front();}return -1;}// 删除一个任务bool popTask(){lock_guard<mutex> locker(m_mutex);if (!m_taskQ.empty()){m_taskQ.pop();return true;}return false;}
private:TaskQueue() = default;static TaskQueue m_obj;queue<int> m_taskQ;mutex m_mutex;
};
TaskQueue TaskQueue::m_obj;int main()
{thread t1([]() {TaskQueue* taskQ = TaskQueue::getInstance();for (int i = 0; i < 100; ++i){taskQ->addTask(i + 100);cout << "+++push task: " << i + 100 << ", threadID: " << this_thread::get_id() << endl;this_thread::sleep_for(chrono::milliseconds(500));}});thread t2([]() {TaskQueue* taskQ = TaskQueue::getInstance();this_thread::sleep_for(chrono::milliseconds(100));while (!taskQ->isEmpty()){int data = taskQ->takeTask();cout << "---take task: " << data << ", threadID: " << this_thread::get_id() << endl;taskQ->popTask();this_thread::sleep_for(chrono::seconds(1));}});t1.join();t2.join();
}

在上面的程序中有以下几点需要说明一下：

  • 正常情况下，任务队列中的任务应该是一个函数指针（这个指针指向的函数中有需要执行的任务动作），此处进行了简化，用一个整形数代替了任务队列中的任务。
  • 任务队列中的互斥锁保护的是单例对象的中的数据也就是任务队列中的数据，上面所说的线程安全指的是在创建单例对象的时候要保证这个对象只被创建一次，和此处完全是两码事儿，需要区别看待。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/599543.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

LeetCode-74. 搜索二维矩阵【数组 二分查找 矩阵】

LeetCode-74. 搜索二维矩阵【数组 二分查找 矩阵】

LeetCode-74. 搜索二维矩阵【数组 二分查找 矩阵】 题目描述&#xff1a;解题思路一&#xff1a;先二分查找行&#xff0c;再二分查找列。解题思路二&#xff1a;暴力遍历&#xff0c;也能过。解题思路三&#xff1a;用python的in。 题目描述&#xff1a; 给你一个满足下述两条…
阅读更多...
【绩效管理】帮助零售企业建立分层分类绩效考核体系项目纪实

【绩效管理】帮助零售企业建立分层分类绩效考核体系项目纪实

购物中心张经理评价&#xff1a;“员工的绩效管理一直是困扰我公司的难题&#xff0c;我们只懂得怎么经营&#xff0c;至于怎么做人力资源管理&#xff0c;真是一点都不懂。这次华恒智信为我们提供的服务对我们的帮助很大。基于企业实际调研情况&#xff0c;华恒智信专家明确指…
阅读更多...
nginx配置实例-负载均衡

nginx配置实例-负载均衡

目录 一、目的&#xff1a;实现效果 二、准备工作 三、实验部署 3.1修改第二台Tomcat服务器的监听端口为8081 3.2修改完成后&#xff0c;重新启动tomcat8081这台服务器。 3.3在浏览器测试 3.4在两台tomcat里面webapps目录中&#xff0c;创建名称是edu的文件夹&#xff0c…
阅读更多...
绝地求生：29.1版本爆料杜卡迪联名、新通行证、成长型AUG和异色、战队皮

绝地求生：29.1版本爆料杜卡迪联名、新通行证、成长型AUG和异色、战队皮

这回的更新爆料是真的多&#xff0c;虽然不会同时上线&#xff0c;本期杜卡迪因为没有轮毂和轮胎&#xff0c;所以车漆的颜色可能会贵一点&#xff0c;但是似乎会有进阶优惠礼包可以购买 合作者战队 本期合作者战队皮肤感觉比较一般&#xff0c;武器不是热门武器&#xff0c;而…
阅读更多...
SpringBoot学习之Kibana下载安装和启动（Mac版）（三十二）

SpringBoot学习之Kibana下载安装和启动（Mac版）（三十二）

一、简介 Kibana是一个开源的分析与可视化平台，设计出来用于和Elasticsearch一起使用的。你可以用kibana搜索、查看存放在Elasticsearch中的数据。Kibana与Elasticsearch的交互方式是各种不同的图表、表格、地图等，直观的展示数据，从而达到高级的数据分析与可视化的目的。 …
阅读更多...
kubernetes集群添加到jumpserver堡垒机里管理

kubernetes集群添加到jumpserver堡垒机里管理

第一步、在kubernetes集群中获取一个永久的token。 jumpserver堡垒机用api的来管理kubernetes&#xff0c;所以需要kubernetes的token&#xff0c;这个token还需要是一个永久的token&#xff0c;版本变更&#xff1a;Kubernetes 1.24基于安全方面的考虑&#xff08;特性门控Le…
阅读更多...
Springboot引入swagger

Springboot引入swagger

讲在前面&#xff1a;在spring引入swagger时&#xff0c;由于使用的JDK、Spring、swagger 的版本不匹配&#xff0c;导致启动报错&#xff0c;一直存在版本依赖问题。所以在此声明清楚使用版本。JDK 1.8、Spring boot 2.6.13、 Swagger 2.9.2。 引入maven依赖 <dependency&…
阅读更多...
2024单品正价起号，直播素材投流选品，【选品课】+【投流课】+【素材课】+【卡首屏】

2024单品正价起号，直播素材投流选品，【选品课】+【投流课】+【素材课】+【卡首屏】

课程下载&#xff1a;https://download.csdn.net/download/m0_66047725/89064168 更多资源下载&#xff1a;关注我。 课程内容: 01 01 1.如何养账号过风控,mp4 01 1.如何搭建一条计划(1)..mp4 02 1.如何搭建一条计划(2)..mp4 02 02 2.单品起号方案如何选择,mp4 03 2.-比…
阅读更多...
java算法day46 | 动态规划part08 ● 139.单词拆分 ● 关于多重背包，你该了解这些！ ● 背包问题总结篇！

java算法day46 | 动态规划part08 ● 139.单词拆分 ● 关于多重背包，你该了解这些！ ● 背包问题总结篇！

139.单词拆分 完全背包问题&#xff0c;只不过装入背包时需要附加一个判断条件。 class Solution {public boolean wordBreak(String s, List<String> wordDict) {boolean[] dpnew boolean[s.length()1];dp[0]true;for(int j1;j<s.length();j){for(int i0;i<wordD…
阅读更多...
关于Mac使用idea问题

关于Mac使用idea问题

多窗口切换问题 如果出现Mac打开idea新的项目&#xff0c;发现始终就一个窗口&#xff0c;不能像window那样多窗口&#xff0c;比如 只能这样来回点着切换&#xff0c;提供以下方案 1.方案一 则在idea里多个项目会呈tab页切换&#xff0c;也是始终一个窗口&#xff0c;只是多了…
阅读更多...
如何成为一名优秀的工程师下

如何成为一名优秀的工程师下

身为工程师&#xff0c;理所当然要重视实践&#xff0c;自然科学不管发展到何时都离不开实验。 电子学本身就是 为了指导工程实践。所以不要谈空洞的理论。现在很多毕业生都面临这样的问题&#xff0c;总是谈一些空洞的理论&#xff0c;甚至错误的但还不以为然的理论。实践可以…
阅读更多...
OpenCV 使用freetype在图像上写中文

OpenCV 使用freetype在图像上写中文

​​​​​​ #include "opencv2/opencv.hpp" #include "opencv2/freetype.hpp"static cv::Ptr<cv::freetype::FreeType2> getFreeType() {static cv::Ptr<cv::freetype::FreeType2> ft2;if (ft2.empty()){ft2 cv::freetype::createFreeType…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023