深入理解单例模式:如何确保一个类只有一个实例?

这篇具有很好参考价值的文章主要介绍了深入理解单例模式:如何确保一个类只有一个实例?。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

欢迎来到英杰社区
https://bbs.csdn.net/topics/617804998

欢迎来到阿Q社区
https://bbs.csdn.net/topics/617897397

前言

单例模式(Singleton Pattern)是一种常用的设计模式,用于确保一个类只有一个实例,并提供全局访问点。虽然在表面上看起来很简单,但深入理解单例模式可以帮助我们更好地应用它,避免潜在的问题。

在本文中,我们将深入探讨单例模式的核心思想、实现方式和使用场景。首先,我们将介绍单例模式的概念和作用,以及为什么要使用单例模式。其次,我们将讨论几种常见的单例模式实现方式,包括懒汉模式、饿汉模式、双重检查锁定模式和静态内部类模式。我们将比较它们的优缺点,以及在多线程环境下如何确保线程安全。

通过深入理解单例模式,我们可以更好地应用它来解决实际的问题。无论是在多线程环境下确保只有一个实例,还是在需要全局访问点的情况下,单例模式都是一个有力的工具。同时,我们也要注意单例模式可能带来的一些副作用,例如对代码的耦合性增加和单元测试的困难。

在本文中,我们将通过详细的解释、示例代码和实际案例,帮助读者深入理解单例模式,并能够在实践中灵活应用。无论是初学者还是有经验的开发者,都可以从本文中获得对单例模式的全面认识和实践指导。

深入理解单例模式,让我们更好地应用它,提高代码的可维护性和可扩展性。

单例模式

单例模式(Singleton Pattern)是一种常见的设计模式,用于确保一个类只有一个实例,并提供全局访问点。

在单例模式中,类的构造函数被私有化,确保外部无法直接创建对象实例。同时,类内部定义一个静态成员变量用于保存唯一实例,并提供一个公共的静态方法用于获取该实例。

以下是一个简单的单例模式的示例代码:

java
public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有化构造函数
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在上述代码中,Singleton 类的构造函数被私有化,确保外部无法直接创建对象实例。通过定义一个静态的 instance 变量,在第一次调用 getInstance() 方法时进行实例化,实现了懒加载的效果。之后的调用都直接返回已经创建的实例。

单例模式的优点是实现简单,可以确保一个类只有一个实例,并提供全局访问点,方便其他对象直接使用该实例。此外,由于只有一个实例存在,可以节省资源。

然而,单例模式也有一些缺点。例如,在多线程环境下,需要考虑并发访问的线程安全性,以避免破坏单例的特性。另外,由于单例对象存在全局访问点,可能会导致代码的耦合性增加,不利于单元测试和模块化开发。

在使用单例模式时,需要根据具体的需求和场景来决定是否使用该模式,并考虑线程安全的实现方式。

饿汉模式

饿汉模式(Eager Initialization)是一种常见的单例设计模式,在该模式下,单例对象在类加载时就被创建,并在整个应用程序生命周期中保持唯一实例。

实现饿汉模式的关键是将构造函数私有化,确保外部无法直接创建对象实例。同时,类内部定义一个静态成员变量用于保存唯一实例,并在类加载时进行初始化。最后,提供一个公共的静态方法用于获取该实例。

以下是一个简单的饿汉模式的示例代码:


public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
        // 私有化构造函数
    }

    public static Singleton getInstance() {
        return instance;
    }
}

在上述代码中,Singleton 类的构造函数被私有化,确保外部无法直接创建对象实例。同时,通过定义一个静态的 instance 变量,并在类加载时进行初始化,实现了在整个应用程序中只有一个唯一实例的效果。外部通过调用 getInstance() 方法获取该实例。

#include<mutex>
#include<iostream>
#include<atomic>
using namespace std;

/*饿汉模式
class singleton {
public:
//	singleton() = delete;
	singleton(const singleton& s) = delete;
	singleton& operator=(const singleton& s) = delete;
	static singleton* getstatic() {
		return st;
	}
	void print() {
		cout << "12321" << endl;
	}
private:
	singleton() = default;
//	singleton(const singleton& s) = default;
	static singleton* st;

};
singleton* singleton::st = new singleton;
int main()
{
	singleton* single = singleton::getstatic();
	single->print();

	return 0;

使用饿汉模式的优点是实现简单,线程安全,因为在类加载时就已经创建了实例。但也有一些缺点,例如如果单例对象比较复杂,初始化时间较长,会导致程序启动时耗费较多时间。此外,如果该单例对象在整个应用程序生命周期中没有被使用,也会造成资源的浪费。

因此,在选择设计模式时,需要根据具体的需求和场景来决定是否使用饿汉模式。

懒汉模式

懒汉模式(Lazy Initialization)是一种常见的单例设计模式,与饿汉模式相比,它延迟了单例对象的创建时间,即在第一次使用时才进行实例化。

实现懒汉模式的关键是将构造函数私有化,确保外部无法直接创建对象实例。同时,类内部定义一个静态成员变量用于保存唯一实例,并提供一个公共的静态方法用于获取该实例。在获取实例的方法中,会先判断实例是否已经被创建,如果没有则进行实例化。

以下是一个简单的懒汉模式的示例代码:

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有化构造函数
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在上述代码中,Singleton 类的构造函数被私有化,确保外部无法直接创建对象实例。通过定义一个静态的 instance 变量,在第一次调用 getInstance() 方法时进行实例化,实现了懒加载的效果。之后的调用都直接返回已经创建的实例。

懒汉模式的优点是实现简单,只有在需要使用单例对象时才进行实例化,可以节省资源。但也存在一些问题,例如在多线程环境下,如果多个线程同时调用 getInstance() 方法,并且实例尚未被创建,可能会导致创建多个实例,破坏了单例的特性。因此,在懒汉模式中需要考虑线程安全的实现方式,例如使用双重检查锁定(Double-Checked Locking)或者静态内部类。

//懒汉模式文章来源地址https://www.toymoban.com/news/detail-796510.html

class singleton {
public:
	//	singleton() = delete;
	singleton(const singleton& s) = delete;
	singleton& operator=(const singleton& s) = delete;
	static singleton* getstatic() {
		
		if (st == nullptr) {
			st = new singleton;
		}
		return st;
	}

	//利用互斥锁解决多线程问题(有问题)
	static singleton* getstatic() {
		if (st == nullptr) {
			m_mutex.lock();
			if (st == nullptr) {

				st = new singleton;
			}
			m_mutex.unlock();
		}
		
		return st;
	}

	//利用原子变量解决底层问题  
		static singleton* getstatic() {
			singleton* st = ato.load();
			if (st == nullptr) {
			m_mutex.lock();
			st = ato.load();
			if (st == nullptr) {
				st = new singleton;
				ato.store(st);
			}
			m_mutex.unlock();
		}
		return st;
	}
		//或者利用·局部静态对象解决多线程问题

	void print() {
	cout << "12321" << endl;
	}
private:
	singleton() = default;
	//	singleton(const singleton& s) = default;
	static singleton* st;

	static mutex m_mutex;
	static atomic<singleton*>  ato;

};
singleton* singleton::st = nullptr;
mutex singleton::m_mutex;
atomic<singleton*> singleton::ato;

int main()
{
	singleton* single = singleton::getstatic();
	single->print();

	return 0;
}

到了这里,关于深入理解单例模式:如何确保一个类只有一个实例?的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • RabbitMQ多消费者实例时,保证只有一个消费者进行消费(单活消费者模式)

    有一种业务场景,当人员组织结构变更时,会有大量数据进行推送。这些数据类型有的是add,有的是update,并且必须先add,才能进行update。 这时,为了保证消费顺序,需要 只有一个实例进行按顺序消费,其他实例仅提供日常对外服务 ,不进行消息消费。当唯一消费实例无法

    2024年02月11日
    浏览(48)
  • 如何理解单例模式?

    单例模式(Singleton Pattern):采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。 通俗点来讲:就是一个男人只能有一个老婆,一个女人只能有一个老公 单例模式一共有8种方式实现,下面一一举例: 实现步

    2023年04月08日
    浏览(33)
  • 如何理解单例模式----饿汉式?

    目录 1.前言 2.本质 3.代码默写 在面试中,理解和掌握单例模式是非常重要的。本文旨在帮助读者深入理解饿汉式单例模式,并通过简洁明了的解释和示例代码,使读者能够轻松掌握并默写出饿汉式单例模式的代码实现。 饿汉式单例模式是一种单例设计模式的实现方式,它在

    2024年01月18日
    浏览(41)
  • [设计模式Java实现附plantuml源码~创建型] 确保对象的唯一性~单例模式

    前言: 为什么之前写过Golang 版的设计模式,还在重新写 Java 版? 答:因为对于我而言,当然也希望对正在学习的大伙有帮助。Java作为一门纯面向对象的语言,更适合用于学习设计模式。 为什么类图要附上uml 因为很多人学习有做笔记的习惯,如果单纯的只是放一张图片,那

    2024年01月19日
    浏览(57)
  • 深入理解数据库事务:确保数据完整性与一致性

    在现代信息系统中,数据是至关重要的资产之一。作为一名后端开发人员,与数据库的交道必不可少,为了确保数据的完整性、一致性和可靠性,数据库引入了事务的概念。本次将带您深入了解数据库事务的重要性、特性以及如何在应用程序中正确地使用事务来维护数据的稳

    2024年02月12日
    浏览(45)
  • 单例模式实例

    2023年04月09日
    浏览(35)
  • unity 单例模式(实例详解)

    以下是一个简单的C#实现Unity中单例模式的例子: 在C#中, protected SingletonClass() {} 这个构造函数的作用是限制类的实例化方式。在这个单例模式实现中,将构造函数设为 protected 有以下几点意义: 防止外部直接创建实例 :由于构造函数是受保护的(protected),所以其他类无法

    2024年01月23日
    浏览(32)
  • JavaEE 初阶篇-深入了解单例模式(经典单例模式:饿汉模式、懒汉模式)

    🔥博客主页: 【 小扳_-CSDN博客】 ❤感谢大家点赞👍收藏⭐评论✍ 文章目录         1.0 单例模式的概述         2.0 单例模式 - 饿汉式单例         2.1 关于饿汉式单例的线程安全问题         3.0 单例模式 - 懒汉式单例         3.1 关于懒汉式单例的线程安全问题      

    2024年04月15日
    浏览(48)
  • 单例模式--理解

    单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时,为了防止频繁地创建对象使得内存飙升,单例模式可以让程序仅在内存中创建一个对象,让所有需要调用的地方都共享这一单例对象。 单例模式有两种类型: 懒汉式

    2024年04月12日
    浏览(35)
  • 全局单身汉:深入理解 Python 中的单例对象

    项目 描述 搜索引擎 Google 、Bing Python 官方文档 项目 描述 Python 解释器 3.10.6 单例对象 在 Python 中,单例对象是一种设计模式,旨在确保在应用程序中只有一个特定类的实例。这意味着无论创建多少个该类的实例,都将始终引用相同的实例。 单例对象的优缺点 单例对象的优点

    2024年02月02日
    浏览(45)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包