美文网首页
Python-c++的23种设计模式- 1 单例模式

Python-c++的23种设计模式- 1 单例模式

作者: James999 | 来源:发表于2023-01-29 11:24 被阅读0次

原文地址

1. Python单例模式

总线是计算机各种功能部件或者设备之间传送数据、控制信号等信息的公共通信解决方案之一。
现假设有如下场景：某中央处理器（CPU）通过某种协议总线与一个信号灯相连，信号灯有64种颜色可以设置，中央处理器上运行着三个线程，都可以对这个信号灯进行控制，并且可以独立设置该信号灯的颜色。
抽象掉协议细节（用打印表示），如何实现线程对信号等的控制逻辑。
加线程锁进行控制，无疑是最先想到的方法，但各个线程对锁的控制，无疑加大了模块之间的耦合。下面，我们就用设计模式中的单例模式，来解决这个问题。
什么是单例模式？单例模式是指：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
具体到此例中，总线对象，就是一个单例，它仅有一个实例，各个线程对总线的访问只有一个全局访问点，即惟一的实例。
Python代码如下：

# encoding=utf8
import threading
import time
# 这里使用方法__new__来实现单例模式


class Singleton(object):  # 抽象单例
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            orig = super(Singleton, cls)
            cls._instance = orig.__new__(cls, *args, **kw)
        return cls._instance
# 总线


class Bus(Singleton):
    lock = threading.RLock()

    def sendData(self, data):
        self.lock.acquire()
        time.sleep(3)
        print("Sending Signal Data...", data)
        self.lock.release()
# 线程对象，为更加说明单例的含义，这里将Bus对象实例化写在了run里


class VisitEntity(threading.Thread):
    my_bus = ""
    name = ""

    def getName(self):
        return self.name

    def setName(self, name):
        self.name = name

    def run(self):
        self.my_bus = Bus()
        print("VisitEntity.run(), self.my_bus %s " % self.my_bus)
        self.my_bus.sendData(self.name)


if __name__ == "__main__":
    for i in range(3):
        print("Entity %d begin to run..." % i)
        my_entity = VisitEntity()
        my_entity.setName("Entity_"+str(i))
        my_entity.start()

运行结果如下：

Entity 0 begin to run...
Entity 1 begin to run...
Entity 2 begin to run...
Sending Signal Data... Entity_0
Sending Signal Data... Entity_1
Sending Signal Data... Entity_2

在程序运行过程中，三个线程同时运行（运行结果的前三行先很快打印出来），而后分别占用总线资源（后三行每隔3秒打印一行）。虽然看上去总线Bus被实例化了三次，但实际上在内存里只有一个实例。

二、单例模式

单例模式是所有设计模式中比较简单的一类，其定义如下：Ensure a class has only one instance, and provide a global point of access to it.（保证某一个类只有一个实例，而且在全局只有一个访问点）

图片.png

三、单例模式的优点和应用

  • 单例模式的优点
    1、由于单例模式要求在全局内只有一个实例，因而可以节省比较多的内存空间；
    2、全局只有一个接入点，可以更好地进行数据同步控制，避免多重占用；
    3、单例可长驻内存，减少系统开销。

  • 单例模式的应用举例
    1、生成全局惟一的序列号；
    2、访问全局复用的惟一资源，如磁盘、总线等；
    3、单个对象占用的资源过多，如数据库等；
    4、系统全局统一管理，如Windows下的Task Manager；
    5、网站计数器。

四、单例模式的缺点

1、单例模式的扩展是比较困难的；
2、赋于了单例以太多的职责，某种程度上违反单一职责原则（六大原则后面会讲到）;
3、单例模式是并发协作软件模块中需要最先完成的，因而其不利于测试；
4、单例模式在某种情况下会导致“资源瓶颈”。

2. C++ 单例模式:

什么是单例模式

单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。

为什么使用单例模式

在应用系统开发中，我们常常有以下需求：

1.需要生成唯一序列的环境
2.需要频繁实例化然后销毁的对象。
3.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
4.方便资源相互通信的环境

  1. 其他。。。

实际案例:

多线程中网络资源初始化
回收站机制
任务管理器
应用程序日志管理。

单例模式实现步骤

构造函数私有化提供一个全局的静态方法，访问唯一对象类中定义一个静态指针，指向唯一对象。
图片.png

单例模式实现代码

  • 懒汉式
#include <iostream>
using namespace std;
//懒汉式
class SingleTon 
{
private:
    SingleTon();
public:
    static SingleTon* m_singleTon;
    static SingleTon* GetInstance();
    void TestPrint();
};
//懒汉式并没有创建单例对象
SingleTon* SingleTon::m_singleTon = NULL;       
int main()
{
    SingleTon* p1 = SingleTon::GetInstance();
    SingleTon* p2 = SingleTon::GetInstance();
    cout << "p1:"<<  hex << p1 << endl;
    cout << "p2:" << hex << p2 << endl;
    p1->TestPrint();
    p2->TestPrint();
    return 0;
}
SingleTon::SingleTon()
{
    m_singleTon = NULL;
    cout << "构造了对象....." << endl;
}
SingleTon* SingleTon::GetInstance()
{
    if (m_singleTon == NULL) 
    {
        m_singleTon = new SingleTon;
    }
    return m_singleTon;
}
void SingleTon::TestPrint()
{
    cout << "测试调用....." << endl;
}
  • 饿汉式
#include <iostream>
using namespace std;
//懒汉式
class SingleTon 
{
private:
    SingleTon();
public:
    static SingleTon* m_singleTon;
    static SingleTon* GetInstance();
    void TestPrint();
};
//饿汉式创建单例对象
SingleTon* SingleTon::m_singleTon = new SingleTon;      
int main()
{
    SingleTon* p1 = SingleTon::GetInstance();
    SingleTon* p2 = SingleTon::GetInstance();
    cout << "p1:"<<  hex << p1 << endl;
    cout << "p2:" << hex << p2 << endl;
    p1->TestPrint();
    p2->TestPrint();
    return 0;
}
SingleTon::SingleTon()
{
    m_singleTon = NULL;
    cout << "构造了对象....." << endl;
}
SingleTon* SingleTon::GetInstance()
{
    return m_singleTon;
}
void SingleTon::TestPrint()
{
    cout << "测试调用....." << endl;
}

单例模式优缺点

  • 优点：
    在内存中只有一个对象，节省内存空间；避免频繁的创建销毁对象，可以提高性能；避免对共享资源的多重占用，简化访问；为整个系统提供一个全局访问点。

  • 缺点：
    不适用于变化频繁的对象；如果实例化的对象长时间用，系统会认为该对象是垃圾而被回收，这可能会导致对象状态的丢失；

C++11实现线程安全的单例模式

  1. 饿汉模式
    　　使用饿汉模式实现单例是十分简单的，并且有效避免了线程安全问题，因为将该单例对象定义为static变量，程序启动即将其构造完成了。代码实现：
class Singleton {
public:
  static Singleton *GetInstance() { return singleton_; }

  static void DestreyInstance() {
    if (singleton_ != NULL) {
      delete singleton_;
    }
  }

private:
  // 防止外部构造。
  Singleton() = default;

  // 防止拷贝和赋值。
  Singleton &operator=(const Singleton &) = delete;
  Singleton(const Singleton &singleton2) = delete;

private:
  static Singleton *singleton_;
};

Singleton *Singleton::singleton_ = new Singleton;

int main() {
  Singleton *s1 = Singleton::GetInstance();
  std::cout << s1 << std::endl;

  Singleton *s2 = Singleton::GetInstance();
  std::cout << s2 << std::endl;

  Singleton::DestreyInstance();

  return 0;
}

2.懒汉模式
　　饿汉方式不论是否需要使用该对象都将其定义出来，可能浪费了内存，或者减慢了程序的启动速度。所以使用懒汉模式进行优化，懒汉模式即延迟构造对象，在第一次使用该对象的时候才进行new该对象。

而懒汉模式会存在线程安全问题，最出名的解决方案就是Double-Checked Locking Pattern (DCLP)双重检查锁。使用两次判断来解决线程安全问题并且提高效率。代码实现：

#include <iostream>
#include <mutex>

class Singleton {
public:
　　static Singleton* GetInstance() {
　　　　if (instance_ == nullptr) {
　　　　　　std::lock_guard<std::mutex> lock(mutex_);
　　　　　　if (instance_ == nullptr) {
　　　　　　　　instance_ = new Singleton;
　　　　　　}
　　　　}

　　　　return instance_;
　　}
　　~Singleton() = default;
　　// 释放资源。
　　void Destroy() {
　　　　if (instance_ != nullptr) {
　　　　　　delete instance_;
　　　　　　instance_ = nullptr;
　　　　}
　　}

　　void PrintAddress() const {
　　　　std::cout << this << std::endl;
　　}

private:
　　Singleton() = default;

　　Singleton(const Singleton&) = delete;
　　Singleton& operator=(const Singleton&) = delete;

private:
　　static Singleton* instance_;
　　static std::mutex mutex_;
};

Singleton* Singleton::instance_ = nullptr;
std::mutex Singleton::mutex_;

int main() {
　　Singleton* s1 = Singleton::GetInstance();
　　s1->PrintAddress();

　　Singleton* s2 = Singleton::GetInstance();
　　s2->PrintAddress();

　　return 0;
}
  1. 懒汉模式优化
    　　上述代码有一个问题，当程序使用完该单例，需要手动去调用Destroy()来释放该单例管理的资源。如果不去手动释放管理的资源（例如加载的文件句柄等），虽然程序结束会释放这个单例对象的内存，但是并没有调用其析构函数去关闭这些管理的资源句柄等。解决办法就是将该管理的对象用智能指针管理。代码如下：
#include <iostream>
#include <memory>
#include <mutex>

class Singleton {
public:
　　static Singleton& GetInstance() {
　　　　if (!instance_) {
　　　　　　std::lock_guard<std::mutex> lock(mutex_);
　　　　　　if (!instance_) {
　　　　　　　　instance_.reset(new Singleton);
　　　　　　}
　　　　}

　　　　return *instance_;
　　}

　　~Singleton() = default;

　　void PrintAddress() const {
　　　　std::cout << this << std::endl;
　　}

private:
　　Singleton() = default;

　　Singleton(const Singleton&) = delete;
　　Singleton& operator=(const Singleton&) = delete;

private:
　　static std::unique_ptr<Singleton> instance_;
　　static std::mutex mutex_;
};

std::unique_ptr<Singleton> Singleton::instance_;
std::mutex Singleton::mutex_;

int main() {
　　Singleton& s1 = Singleton::GetInstance();
　　s1.PrintAddress();

　　Singleton& s2 = Singleton::GetInstance();
　　s2.PrintAddress();

　　return 0;
}

  1. Double-Checked Locking Pattern存在的问题
    　　Double-Checked Locking Pattern (DCLP)实际上也是存在严重的线程安全问题。Scott Meyers and 和Alexandrescu写的一篇文章里面专门分析了这种解决方案的问题C++ and the Perils of Double-Checked Locking。文章截图：


    图片.png
    图片.png
    图片.png

比如刚刚实现方式很容易发现其存在线程安全问题。

if (instance_ == nullptr) { \\ 语句1
　　std::lock_guard<std::mutex> lock(mutex_);
　　if (instance_ == nullptr) {
　　　　instance_ = new Singleton; \\ 语句2
　　}
}

线程安全问题产生的原因是多个线程同时读或写同一个变量时，会产生问题。
如上代码，对于语句2是一个写操作，我们用mutex来保护instance_这个变量。但是语句1是一个读操作，if (instance_ == nullptr)，这个语句是用来读取instance_这个变量，而这个读操作是没有锁的。所以在多线程情况下，这种写法明显存在线程安全问题。
《C++ and the Perils of Double-Checked Locking》这篇文章中提到：

instance_ = new Singleton;

这条语句实际上做了三件事，第一件事申请一块内存，第二件事调用构造函数，第三件是将该内存地址赋给instance_。

但是不同的编译器表现是不一样的。可能先将该内存地址赋给instance_，然后再调用构造函数。这是线程A恰好申请完成内存，并且将内存地址赋给instance_，但是还没调用构造函数的时候。线程B执行到语句1，判断instance_此时不为空，则返回该变量，然后调用该对象的函数，但是该对象还没有进行构造。

  1. 使用std::call_once实现单例
    在C++11中提供一种方法，使得函数可以线程安全的只调用一次。即使用std::call_once和std::once_flag。std::call_once是一种lazy load的很简单易用的机制。实现代码如下：
#include <iostream>
#include <memory>
#include <mutex>

class Singleton {
public:
　　static Singleton& GetInstance() {
　　　　static std::once_flag s_flag;
　　　　std::call_once(s_flag, [&]() {
　　　　　　instance_.reset(new Singleton);
　　　　});

　　　　return *instance_;
　　}

　　~Singleton() = default;

　　void PrintAddress() const {
　　　　std::cout << this << std::endl;
　　}

private:
　　Singleton() = default;

　　Singleton(const Singleton&) = delete;
　　Singleton& operator=(const Singleton&) = delete;

private:
　　static std::unique_ptr<Singleton> instance_;
};

std::unique_ptr<Singleton> Singleton::instance_;

int main() {
　　Singleton& s1 = Singleton::GetInstance();
　　s1.PrintAddress();

　　Singleton& s2 = Singleton::GetInstance();
　　s2.PrintAddress();

　　return 0;
}

6.使用局部静态变量实现懒汉
使用C++局部静态变量也可解决上述问题。

#include <iostream>

class Singleton {
public:
　　static Singleton& GetInstance() {
　　　　static Singleton intance;
　　　　return intance;
　　}

　　~Singleton() = default;

private:
　　Singleton() = default;

　　Singleton(const Singleton&) = delete;
　　Singleton& operator=(const Singleton&) = delete;
};

int main() {
　　Singleton& s1 = Singleton::GetInstance();
　　std::cout << &s1 << std::endl;

　　Singleton& s2 = Singleton::GetInstance();
　　std::cout << &s2 << std::endl;

　　return 0;
}

局部静态变量可以延迟对象的构造，等到第一次调用时才进行构造。
C++11中静态变量的初始化时线程安全的。通过调试，在进行局部静态变量初始化的时候，确实会执行以下代码来保证线程安全。

#include <iostream>

class Singleton {
public:
　　static Singleton& GetInstance() {
　　　　static Singleton intance;
　　　　return intance;
　　}

　　~Singleton() = default;

private:
　　Singleton() = default;

　　Singleton(const Singleton&) = delete;
　　Singleton& operator=(const Singleton&) = delete;
};

int main() {
　　Singleton& s1 = Singleton::GetInstance();
　　std::cout << &s1 << std::endl;
　　Singleton& s2 = Singleton::GetInstance();
　　std::cout << &s2 << std::endl;
　　return 0;
}

参考1
参考2
参考3

相关文章

  • 设计模式第二篇、单例设计模式

    目录1、什么是单例设计模式2、单例设计模式的简单实现3、单例设计模式面临的两个问题及其完整实现4、单例设计模式的应...

  • 单例模式Java篇

    单例设计模式- 饿汉式 单例设计模式 - 懒汉式 单例设计模式 - 懒汉式 - 多线程并发 单例设计模式 - 懒汉...

  • 设计模式

    设计模式简介 单例设计模式 问题:单例设计模式是什么?为什么要学它？怎么用它？ 1.定义:单例模式（Singlet...

  • python中OOP的单例

    目录 单例设计模式 __new__ 方法 Python 中的单例 01. 单例设计模式 设计模式设计模式 是 前人...

  • 单例

    目标 单例设计模式 __new__ 方法 Python 中的单例 01. 单例设计模式 设计模式设计模式 是 前人...

  • 设计模式 - 单例模式

    设计模式 - 单例模式 什么是单例模式 单例模式属于创建型模式，是设计模式中比较简单的模式。在单例模式中，单一的类...

  • python之理解单例模式

    python之理解单例模式 1、单例模式 单例模式（Singleton Pattern）是一种常见的软件设计模式，...

  • 设计模式学习之单例模式

    设计模式之单例模式 1 什么是单例模式 在维基百科中单例模式定义为 单例模式，也叫单子模式，是一种常用的软件设计模...

  • Node.js与单例模式

    1、前端的JavaScript单例模式 单例模式是非常常用的设计模式，前端的JavaScript中单例模式代码可能...

  • 单例模式

    1. 单例模式 在面向对象的程序设计中, 单例模式是最简单的设计模式,这种类型的设计模式属于创建型模型,所谓单例....

网友评论

      本文标题：Python-c++的23种设计模式- 1 单例模式

      本文链接：https://www.haomeiwen.com/subject/iytphdtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Python-c++的23种设计模式- 1 单例模式|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！