一文带你搞懂单例设计模式

最新推荐文章于 2024-07-07 23:15:22 发布
置顶 最新推荐文章于 2024-07-07 23:15:22 发布
阅读量293 收藏 12
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34161458/article/details/106819795
版权

更多知识，请移步我的小破站：http://hellofriend.top

什么是单例设计模式？

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。

通过单例模式可以保证系统中，应用该模式的类只有一个实例。即一个类只有一个对象实例。

在Java语言中，单例带来了两大好处：

  1. 对于频繁使用的对象（数据源、Session工厂），可以省略创建对象所花费的时间，这对于重量级的对象而言，是非常可观的一笔系统开销。
  2. 由于new操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻GC压力，缩短GC停顿时间。

具体实现

需要：
（1）将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
（2）在该类内部产生一个唯一的实例化对象，并且将其封装为 private static 类型。
（3）定义一个静态方法返回这个唯一对象。

实现一：饿汉式 / 静态常量

  • 立即加载就是使用类的时候已经将对象创建完毕（不管以后会不会使用到该实例化对象，先创建了）。常见的实现办法就是直接 new 实例化。

代码如下：

public class HungrySingletonStaticInstance {
    public static void main(String[] args) {
        System.out.println("======HungrySingletonStaticInstance======");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1 == instance2：" + (instance1 == instance2));//true

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton {

    // 将自身实例化对象设置为一个属性，并用static、final修饰
    private final static Singleton instance = new Singleton();

    // 构造方法私有化
    private Singleton() {}

    // 提供静态方法返回该实例
    public static Singleton getInstance() {
        return instance;
    }
}

“饿汉模式” 的优缺点分析：

  • 优点：实现起来简单，没有多线程同步问题。
  • 缺点：当类 Singleton 被加载的时候，会初始化 static 的 instance，静态变量被创建并分配内存空间，从这以后，这个 static 的 instance对象便一直占着这段内存，可能造成内存浪费（即便你还没有用到这个实例）。当类被卸载时，静态变量被摧毁，并释放所占有内存，在某些特定条件下会耗费内存。
  • 补充：如果方法内有其他 static 方法，调用该方法此类也会加载初始化。

实现二：饿汉式 / 静态代码块

public class HungrySingletonStaticBlock {
    public static void main(String[] args) {
        System.out.println("======HungrySingletonStaticBlock======");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1 == instance2：" + (instance1 == instance2));//true

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton {

    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}
  • 如果方法内有其他static方法，调用该方法此类也会加载初始化。

实现三：懒汉式 / 线程不安全

  • 延迟加载就是调用 getInstance() 方法时实例才被创建（先不急着实例化出对象，等要用的时候才创建出来)。常见的实现方法就是在getInstance() 方法中进行 new 实例化。
public class LazyLoadingSingletonThreadUnSafe {
    public static void main(String[] args) {
        System.out.println("======LazySingletonThreadUnsafe======");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1 == instance2：" + (instance1 == instance2));//true

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton {

    // 将自身实例化对象设置为一个属性，并用static修饰
    private static Singleton instance;

    // 构造方法私有化
    private Singleton() {}

    // 静态方法返回该实例
    public static Singleton getInstance() {
        if (instance == null) {
            //TODO 线程在这里被阻塞，则此时对象没有被创建，UnSafe
            instance = new Singleton();
        }
        return instance;
    }
}

“懒汉模式” 的优缺点分析：

  • 优点：实现起来比较简单，当类 Singleton 被加载的时候，静态变量 static 的 instance 未被创建并分配内存空间，当getInstance() 方法第一次被调用时，初始化instance变量，并分配内存，因此在某些特定条件下会节约了内存。
  • 缺点：在多线程环境中，这种实完现方法是错误的，不能保证单例的状态。
  • 补充：如果方法内有其他static方法，调用该方法此类不会加载初始化。

实现四：懒汉式 / 线程安全 Sync

  • 静态方法返回该实例，加 Synchronized 关键字实现同步。
public class LazyLoadingSingletonSync {
    public static void main(String[] args) {
        System.out.println("======LazyLoadingSingletonSync======");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1 == instance2：" + (instance1 == instance2));//true

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton {

    // 将自身实例化对象设置为一个属性，并用static修饰
    private static Singleton instance;

    // 构造方法私有化
    private Singleton() {}

    // 静态方法返回该实例
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

线程安全的“懒汉模式”（加锁）的优缺点：

  • 优点：在多线程情形下，保证了“懒汉模式”的线程安全。
  • 缺点：在多线程情形下，synchronized方法通常效率低，显然这不是最佳的实现方案。
  • 补充：如果方法内有其他static方法，调用该方法此类不会加载初始化。

实现五：DCL双重检查锁定机制

（DCL：Double Checked Locking）

public class LazyLoadingSingletonDCL {
    public static void main(String[] args) {
        System.out.println("======LazyLoadingSingletonDCL======");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1 == instance2：" + (instance1 == instance2));//true

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton {

    // 将自身实例化对象设置为一个属性，并用 volatile、static 修饰
    private volatile static Singleton instance;

    // 构造方法私有化
    private Singleton() {}

    // 静态方法返回该实例
    public static Singleton getInstance() {
        // 第一次检查instance是否被实例化出来
        if (instance == null) {
            synchronized (Singleton.class) {
                // 某个线程取得了类锁，实例化对象前第二次检查 instance 是否已经被实例化
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
  • 该方法是单例模式推荐的实现方式。内存占用率高，效率高，线程安全，多线程操作原子性。
  • 如果方法内有其他 static 方法，调用该方法此类不会加载初始化。

实现六：静态内部类

public class StaticInternalSingleton {
    public static void main(String[] args) {
        System.out.println("======StaticInternalSingleton======");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println("instance1 == instance2：" + (instance1 == instance2));//true

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}


class Singleton {

    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    private static class SingletonHolder {
        //加载 Singleton 类时并不会加载内部类
        private static final Singleton INSTANCE = new Singleton();
    }
}
  • 第一次加载 Singleton 类时并不会加载内部类初始化 Instance，只有第一次调用 getInstance 方法时虚拟机加载 SingletonHolder 并初始化 Instance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。

实现七：枚举单例

该方法借助 JDK 1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

public class EnumSingleton {
    public static void main(String[] args) {
        System.out.println("======EnumSingleton======");
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println("instance1 == instance2：" + (instance1 == instance2));//true

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());

        instance1.method();
        instance2.method();
    }
}

enum Singleton {
    INSTANCE;

    public void method() {
        System.out.println("EnumSingleton");
    }
}

JDK 中单例模式的应用之 Runtime 类

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }
	//TODO 私有化构造器
    private Runtime() {}

很显然，JDK 中的 Runtime 类使用的是本文的 实现一：饿汉式 / 静态常量来实现的，由于 Runtime 类在程序运行中一定会使用到，所以并不会带来饿汉式的空间浪费问题。

小总结

（1）单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统的性能。

（2）当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new。

小白不菜、
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文带你读懂计算机视觉
01-27
最近，我已经阅读了很多与计算机视觉相关的资料并做了大量实验，这里介绍了在该领域学习和使用过程中有意思的内容。近年来，计算机视觉取得了很大进展。...选择什么，关键是GPU集成视觉的UI应用程序：ownphotos应用：...
一文带你搞懂RTK定位.pdf
03-30
自动驾驶，导航定位RTK讲解
一文搞懂设计模式—单例模式
BookSea的博客
02-04 1037
在软件开发中，有些对象我们只需要一个实例，通过单例模式可以确保一个类只有一个实例
一文带你彻底搞懂设计模式之单例模式！！由浅入深，图文并茂，超超超详细的单例模式讲解！！
m0_63653444的博客
06-28 1096
本篇文章通过图文形式，由浅入深，详细讲解了设计模式中的单例模式的应用
一文彻底搞懂单例设计模式
qq_34800986的博客
03-12 163
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法(静态方法)。 比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。
一文搞懂JAVA单例设计模式的所有实现
weixin_38522648的博客
12-24 830
在Java中，单例模式的实现需要考虑多种因素，包括线程安全、延迟加载、资源利用效率等。同时，反射和序列化/反序列化是破坏单例模式的常见手段。在实现单例时，应考虑这些因素和破坏方式，选择最适合当前应用场景的实现方法。枚举实现是最简单且安全的方法，但在某些情况下可能缺乏灵活性。其他方法如懒汉式、饿汉式、DCL等各有优缺点，应根据具体需求和环境选择合适的实现方式。
【设计模式】一文搞懂单例模式
qq_62095670的博客
05-19 909
在软件开发中，我们经常会遇到需要确保某个类只有一个实例存在的情况，在这种情况下，单例模式成为了一种强大而常用的设计模式。想象一下，当我们需要访问应用程序的配置信息时，我们希望有一个唯一的配置对象来统一管理这些信息，这时，单例模式就能派上用场。然而，单纯地使用单例模式并不足以解决所有问题，在实现单例模式时，我们需要考虑到线程安全性、延迟加载等因素，以确保其在不同情况下的正确性和性能。
一文搞懂单例模式
qq_36059306的博客
07-19 127
原理 一个类只允许创建一个对象，那么这个类就是单例类 代码实现 饿汉式 在程序启动时创建唯一对象 var loggerCreateOnce sync.Once var singleLogger *Logger func newSingleLogger() { filePath := "/log.txt" f, _ := os.Create(filePath) writer := bufio.NewWriter(f) singleLogger = &Logger{fileWriter: wr
一文搞懂设计模式--单例模式
qq_43896330的博客
07-20 130
Hi，大家好呀。今天要说的是单例模式。单例模式的核心思想十分的简单，在开发一个系统的时候，为了保证系统中的数据一致，我们会希望某些特殊的类在整个系统的运行过程中只能存在一个实例。最简单的时间方式就是将这个要求交给开发者，让开发者在开发的时候多加注意。当然，有时候我们不想要开发者人为的来维护这个实例，毕竟人总是会犯错的嘛，一不小心就会造成巨大的损失。因此，开发者们想出了一个设计模式来完成这件事情，这个设计模式就叫做单例模式。*采用懒汉式，才类加载时创建实例*添加volatile关键字防止指令重排。...
一文彻底搞懂java单例模式
specialonion的博客
09-24 150
前言：何谓单例模式？ 单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例。本文介绍3种常见懒汉式+2种常见饿汉式+1种静态内部类实现方式（懒汉式）+枚举实现（饿汉式）。 一、3种常见懒汉式 第一版（线程不安全）（懒汉式） public class Singleton { private Singleton() {} //私有构造函数 private static Singleton instance = null; //单例对象
设计模式1 一文搞懂单例模式
一个好人的博客
05-12 72
单例模式 单例模式就是保证我们使用到的都是同一个对象,主要有四种 饿汉式 懒汉式 静态内部类方式 枚举方式 饿汉式 package com.hejiale.singleton; /** * 饿汉式: * 类加载到内存中,就会实例化一个单例,从而保证线程安全 * 简单实用,推荐使用 * 唯一缺点:就是不论用到与否,在类加载的时候,就会实例化对象 Class.forName("") */ public class Mgr01 { private static final Mgr01 IN
一文带你搞懂匈牙利算法.pdf
03-30
匈牙利算法讲解
一文带你读懂Mysql和InnoDB存储引擎
02-24
作为一名开发人员，在日常的工作中会难以避免地接触到数据库，无论是基于文件的sqlite还是工程上使用非常广泛的MySQL、PostgreSQL，但是一直以来也没有对数据库有一个非常清晰并且成体系的认知，所以最近两个月的...
《C++20设计模式》命令模式思考
最新发布
Ten_years_star的博客
07-07 447
哎！只要是书上写的和经典设计模式不同，我就会很伤脑筋。😩 **命令模式到底是干什么的？** 答：命令的发送者和接收者完全解耦
设计模式之单例模式
07-03 517
单例模式（Singleton Pattern）是一种常用的软件设计模式，它确保一个类仅有一个实例，并提供一个全局访问点来获取该实例。这个模式在多种场景下都非常有用，比如配置文件的读取、数据库连接、线程池等，这些资源通常只需要一个实例来管理，以避免资源浪费或数据不一致。
Java中的设计模式在实际项目中的应用
微赚淘客开发者博客
07-05 464
设计模式是解决软件设计中常见问题的经验总结，它们提供了一种标准的解决方案，能够帮助开发人员设计出灵活、可扩展和易于维护的代码。在Java中，设计模式尤为重要，因为Java是一种面向对象的语言，设计模式可以帮助开发人员更好地利用面向对象编程的特性。通过合理应用设计模式，可以提高代码的复用性、灵活性和可维护性，降低项目的开发和维护成本，同时提升系统的可靠性和性能。观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。对象，隐藏了对象的创建细节。
秋招突击——设计模式补充——简单工厂模式和策略模式
Blackoutdragon的博客
07-04 1083
今天太晚了，太累了，上午面试的东西，下午花了很多时间去整理，然后有准备了一下奖学金的申领的内容。已经到深夜了。又没有刷算法，又没有完全看完，不过太累了。 明天早点起，加油吧！
秒懂设计模式--学习笔记(6)【创建篇-建造者模式】
qq_28288835的博客
07-04 842
建造者模式（Builder）又称为生成器模式，主要用于对复杂对象的构建、初始化它可以将多个简单的组件对象按顺序一步步组装起来，最终构建成一个复杂的成品对象所构建的对象一定是庞大而复杂的，并且一定是按照既定的制造工序将组件组装起来的。我们通常将负责构建这些大型对象的工程师称为建造者建造者模式的主要目的在于把烦琐的构建过程从不同对象中抽离出来，使其脱离并独立于产品类与工厂类最终实现用同一套标准的制造工序能够产出不同的产品测试类文件复杂的产品类，构建过程相对复杂，需要其他组件组装而成。
一文弄懂责任链设计模式
09-10
责任链设计模式是一种行为型设计模式，用于将请求的发送者和接收者解耦，使多个对象都有机会处理该请求。该模式将这些对象串成链，并沿着这条链传递请求，直到有一个对象能够处理它为止。 责任链模式的核心是定义一个处理请求的抽象类或接口，然后让多个具体的处理者对象继承或实现这个类/接口。每个具体的处理者对象都包含一个对下一个处理者对象的引用，形成一个链式结构。 当一个请求进入责任链时，责任链中的每个处理者都有机会处理该请求。如果可以处理请求，则进行处理；如果不能处理，则将请求传递给下一个处理者，直到有一个处理者能够处理它。 责任链模式的关键点是要找到合适的处理者顺序和条件。通常情况下，责任链模式适用于以下情况： 1. 有多个对象可以处理同一类型的请求，但具体由哪个对象来处理由运行时决定。 2. 不明确请求的接收者，希望请求在一个对象链中流动，直到被处理。 3. 需要动态地指定可以处理请求的对象集合。 使用责任链模式可以实现请求发送者和接收者的解耦，增加代码的灵活性和可扩展性。但同时也需要注意责任链的长度和效率问题，避免责任链过长或造成性能问题。 总结一下，责任链设计模式是一种将请求发送者和接收者解耦的设计模式，通过将多个处理者对象串成链，沿着这条链传递请求，直到有一个处理者能够处理它。这样可以增加代码的灵活性和可扩展性，适用于有多个对象可以处理同一类型请求的情况。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值