设计模式学习(一)单例模式的几种实现方式

这篇具有很好参考价值的文章主要介绍了设计模式学习(一)单例模式的几种实现方式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录
  • 前言
  • 饿汉式
  • 懒汉式
  • 懒汉式DCLP
  • 局部静态式(Meyers' Singleton)
  • 单例模板
  • 参考文章

前言

单例模式,其核心目标是确保在程序运行的过程中,有且只有存在一个实例才能保证他们的逻辑正确性以及良好的效率。因此单例模式的实现思路就是确保一个类有且只有一个实例,并提供一个该实例的全局访问点。
单例模式设计要点:

  • 私有构造、析构
  • 禁止赋值、拷贝
  • 静态私有成员:全局唯一实例
  • 提供一个用于获取全局唯一实例的接口,若实例不存在则创建。

除了上面提到的四点还要注意线程安全以及资源释放的问题。

本文从最基本的懒汉式和饿汉式单例模式开始,循序渐进地讨论单例模式形式的特点及变化过程

饿汉式

饿汉式单例模式的核心思路就是不管需不需要用到实例都要去创建实例。饿汉模式的实例在类产生时候就创建了,它的生存周期和程序一样长。

对于饿汉模式而言,是线程安全的,因为在线程创建之前唯一的实例已经被创建好了。而且在程序的退出阶段,类内唯一实例instance也会被销毁,~CSingleton会被调用,资源可以正常被释放。

//无延迟初始化
//多线程安全,资源自动释放
class CSingleton
{
public:
    static CSingleton* getInstance();
private:
    CSingleton(){std::cout<<"创建了一个对象"<<std::endl;}
    ~CSingleton(){std::cout<<"销毁了一个对象"<<std::endl;}
    CSingleton(const CSingleton&) 			 = delete;
    CSingleton& operator=(const CSingleton&) = delete;
    
    static CSingleton instance;  //将指针改为普通的变量
};
  
CSingleton CSingleton::instance;

CSingleton* CSingleton::getInstance()
{
    return &instance;
}
//测试代码,后面不赘述
int main()
{
    std::cout << "Now we get the instance" << std::endl;
    std::thread t1([](){auto instance = CSingleton::getInstance();});
    std::thread t2([](){auto instance = CSingleton::getInstance();});
    std::thread t3([](){auto instance = CSingleton::getInstance();});

    t1.join();
    t2.join();
    t3.join();
    std::cout << "Now we destroy the instance" << std::endl;
    return 0;
}

测试结果:
设计模式学习(一)单例模式的几种实现方式

饿汉式的缺点:

  • 在程序启动时立即创建单例对象,若单例类中包含耗时的初始化操作时,会增加程序的启动时间
  • 若有多个单例类分布在不同编译单元,且这些单例类间存在依赖关系,那么在初始化时可能会有问题,因为C++标准不能保证不同编译单元中静态对象的初始化顺序

懒汉式

与饿汉式单例模式相比,懒汉式的关键区别在于它延迟了单例实例的创建,即直到第一次被使用时才创建实例:

//延迟初始化
//多线程不安全,资源无法自动释放
class CSingleton
{
public:
    static CSingleton* getInstance();

private:
    CSingleton(){std::cout<<"创建了一个对象"<<std::endl;}
    ~CSingleton(){std::cout<<"销毁了一个对象"<<std::endl;}
    CSingleton(const CSingleton&) 			 = delete;
    CSingleton& operator=(const CSingleton&) = delete;
    
    static CSingleton* instance;  
};

CSingleton* CSingleton::instance; 
 
CSingleton* CSingleton::getInstance()
{
    if(nullptr == instance)
        instance = new CSingleton();
    return instance;
}

测试结果:
设计模式学习(一)单例模式的几种实现方式

但是上述代码有几个缺点:

  • 线程安全问题:多线程环境下不安全,可能会有多个单例实例被创建,这违反了单例模式的原则。
  • 资源释放问题:运行结束无法自动调用析构函数(因为单例对象建立在堆上,在程序结束时,指针变量被销毁了,而它所指向的堆上的内存并没有被销毁),可能会导致资源泄漏。

为了解决线程安全的问题,下面讨论加锁的懒汉式单例模式:

懒汉式DCLP

为了让懒汉式做到线程安全,我们首先会想到加锁:

class CSingleton
{
public:
    ...
    static std::mutex mtx;

private:
    ...
};

CSingleton* CSingleton::instance;
 
std::mutex CSingleton::mtx;
 
CSingleton* CSingleton::getInstance()
{
	mtx.lock();    
    if(nullptr == instance)
    {
        instance = new CSingleton();
    }
    mtx.unlock();    
    return instance;
}

但是要注意,加锁和解锁的操作是需要时间的,上述方法在多线程的情况下,每次调用都会浪费时间在上锁和解锁上,导致效率下降。其实我们真正需要的,只是在instance 初始化时上锁保证线程安全,即只有getInstance()第一次被调用时上锁才是必要的。若在程序中,getInstance()被调用了n次,那么只有第一次调用锁是起真正作用的,其余n-1次做操作都是没必要的。

所以要想改进上述问题,我们在加锁之前先判个空,当判断结果为真(即instance还没有被初始化),才进行加锁操作,然后再次检查instance是否为空。

//双检查锁模式DCLP
CSingleton* CSingleton::getInstance()
{
	if (nullptr == instance)
	{
		mtx.lock();   
	    if(nullptr == instance)
	    {
	        instance = new CSingleton();
	    }
	    mtx.unlock(); 
	}
    return instance;
}

第二次检查必不可少,这是因为在第一次检查instance 和加锁之间,可能会有别的线程对instance 进行初始化。

测试结果:
设计模式学习(一)单例模式的几种实现方式

但是遗憾的是,这种方法其实也不是线程安全的,具体原因可见:补充-指令重排

其实,使用了DCLP的懒汉式单例模式不但线程不安全,而且无法通过RAII机制调用析构函数释放相关资源。具体原因可见:补充-单例模式析构

为了解决线程安全问题和资源释放问题,Scott Meyers提出了局部静态变量形式的单例模式。

局部静态式(Meyers' Singleton)

这种形式的单例模式使用函数中的局部静态变量来代替类中的静态成员指针:

//延迟初始化
//多线程安全,资源自动释放
class CSingleton
{
private:
    CSingleton() {std::cout << "创建了一个对象" << std::endl;}
    ~CSingleton() {std::cout << "销毁了一个对象" << std::endl;}
    CSingleton(const CSingleton&)            = delete;
    CSingleton& operator=(const CSingleton&) = delete;
public:
    static CSingleton& getInstance() 
    {
        static CSingleton instance;
        return instance;
    }
};

//测试代码
int main()
{
    std::cout << "Now we get the instance" << std::endl;
    std::thread t1([](){auto& instance = CSingleton::getInstance();});
    std::thread t2([](){auto& instance = CSingleton::getInstance();});
    std::thread t3([](){auto& instance = CSingleton::getInstance();});

    t1.join();
    t2.join();
    t3.join();
    std::cout << "Now we destroy the instance" << std::endl;
    return 0;
}

测试结果:
设计模式学习(一)单例模式的几种实现方式

对于线程安全问题:在C++11及更高版本中,静态局部变量的初始化是线程安全的。即当多个线程同时首次访问局部静态变量,编译器可以保证其初始化代码仅执行一次,防止了任何可能的竞态条件或重复初始化。

对于资源释放问题:代码中局部静态变量instance的生命周期开始于第一次调用getInstance方法时,终止于程序结束时。在程序的退出阶段局部静态变量instance被销毁,~CSingleton被调用,确保了资源的正确释放。

单例模板

在大型项目中,如果有多个类都被设计为要具有单例行为,那么为了方便这些类的创建,我们可以将单例属性封装为一个模板类,在需要时继承这个模板基类,这样这些子类就可以继承它的单例属性。

因为这种单例模式是基于静态局部变量的,所以它是多线程安全的而且是可以正常进行资源释放的:

template <typename T>
class CSingleton 
{
protected:
    CSingleton(){std::cout<<"创建了一个对象"<<std::endl;}
    ~CSingleton(){std::cout<<"销毁了一个对象"<<std::endl;}
    CSingleton(const CSingleton&)            = delete;
    CSingleton& operator=(const CSingleton&) = delete;

public:
    static T& getInstance() 
    {
        static T instance;
        return instance;
    }
};

//使用模板
class MyClass : public CSingleton<MyClass>
{
    friend class CSingleton<MyClass>;
private:
    MyClass(){std::cout<<"this is MyClass construct"<<std::endl;}
    ~MyClass(){std::cout<<"this is MyClass destruct"<<std::endl;}
public:
    void dosomething()
    {
        std::cout<<"dosomething"<<std::endl;
    }
};

测试结果:
设计模式学习(一)单例模式的几种实现方式

这种形式使用了奇异递归模板模式(Curiously Recurring Template Pattern, CRTP)。在使用时要注意,子类需要将自己作为模板参数传递给CSingleton模板进行模板类实例化,用做基类;同时需要将基类声明为友元,这样才能在通过CSingleton<T>::getInstance()方法创建MyClass唯一实例时,调用到MyClass的私有构造函数。

参考文章

1.C++ 单例模式文章来源地址https://www.toymoban.com/news/detail-841333.html

到了这里,关于设计模式学习(一)单例模式的几种实现方式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Python 实现单例模式的几种方式以及存在的问题

    Python 的模块就是天然的单例模式,因为模块在第一次导入时,会生成 .pyc 文件,当第二次导入时,就会直接加载 .pyc 文件,而不会再次执行模块代码。 直接在其他文件中导入此文件中的对象,这个对象即是单例模式的对象 先执行了类的__new__方法(我们没写时,默认调用ob

    2024年01月22日
    浏览(48)
  • 设计模式学习(一)单例模式补充——单例模式析构

    目录 前言 无法调用析构函数的原因 改进方法 内嵌回收类 智能指针 局部静态变量 参考文章 在《单例模式学习》中提到了,在单例对象是通过 new 动态分配在堆上的情况下,当程序退出时,不会通过C++的RAII机制自动调用其析构函数。本文讨论一下这种现象的原因以及

    2024年03月19日
    浏览(53)
  • 学习笔记-设计模式-创建型模式-单例模式

    一个类只有一个实例,并提供一个全局访问此实例的点,哪怕多线程同时访问。 单例模式主要解决了 一个全局使用的类被频繁的创建和消费 的问题。 单例模式的案例场景 数据库的连接池不会反复创建 spring中一个单例模式bean的生成和使用 在我们平常的代码中需要设置全局

    2024年02月08日
    浏览(52)
  • 设计模式学习(一)单例模式补充——指令重排

    目录 前言 指令重排简介 指令重排对单例模式的影响 改进方法 std::call_once和std::once_flag std::atomic和内存顺序 局部静态变量 总结 参考文章 在《单例模式学习》中曾提到懒汉式DCLP的单例模式实际也不是线程安全的,这是编译器的指令重排导致的,本文就简单讨论一下指令重排

    2024年03月19日
    浏览(46)
  • 设计模式——单例模式8种实现

    1、了解概念: 单例模式是指采用一定的方法保证在整个软件系统种,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)。 个人理解:一个类只能实例化一个对象,其他的使用都是引用这个对象。 单例模式的八种实现方式 单例模式的

    2024年02月21日
    浏览(46)
  • 【开源与项目实战:开源实战】82 | 开源实战三(中):剖析Google Guava中用到的几种设计模式

    上一节课,我们通过 Google Guava 这样一个优秀的开源类库,讲解了如何在业务开发中,发现跟业务无关、可以复用的通用功能模块,并将它们从业务代码中抽离出来,设计开发成独立的类库、框架或功能组件。 今天,我们再来学习一下,Google Guava 中用到的几种经典设计模式:

    2024年02月11日
    浏览(69)
  • 设计模式:单例模式六种实现

    单例模式有多种实现方式,每种方式都有其设计思想、优缺点以及适用的使用场景。以下是一些常见的单例实现方式: 1. 懒汉式(线程不安全) 设计思想 这种实现方式采用了类加载的懒加载机制来保证单例只在第一次使用时被创建。 实现代码 优缺点 优点:延迟加载,只在

    2024年04月12日
    浏览(42)
  • Python入门【​编辑、组合、设计模式_工厂模式实现 、设计模式_单例模式实现、工厂和单例模式结合、异常是什么?异常的解决思路 】(十七)

    👏作者简介:大家好,我是爱敲代码的小王,CSDN博客博主,Python小白 📕系列专栏:python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发 📧如果文章知识点有错误的地方,请指正!和大家一起学习,一起进步👀 🔥如果感觉博主的文章还不错的

    2024年02月14日
    浏览(44)
  • 【设计模式】单例模式、“多例模式”的实现以及对单例的一些思考

    单例模式是设计模式中最简单的一种,对于很多人来说,单例模式也是其接触的第一种设计模式,当然,我也不例外。这种设计模式在学习、面试、工作的过程中广泛传播,相信不少人在面试时遇到过这样的问题:“说说你最熟悉的集中设计模式”,第一个脱口而出的就是单

    2024年02月07日
    浏览(50)
  • 设计模式——C++11实现单例模式(饿汉模式、懒汉模式),与单例的进程

    本文将介绍单例模式,使用C++11实现多个版本的单例模式,分析各自的优缺点。最后提及如何实现一个单例的进程。 单例模式属于创建型模式,提供了一种创建对象的方式。 单例模式确保一个类只有一个实例。通过一个类统一地访问这个实例。 思想:将构造函数设置为私有

    2024年02月09日
    浏览(50)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包