设计模式之单例模式

最新推荐文章于 2024-10-16 21:36:54 发布
最新推荐文章于 2024-10-16 21:36:54 发布
阅读量167 收藏
点赞数
分类专栏： Java学习 文章标签： 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ABestRookie/article/details/124439942
版权
本文深入探讨了Java中的单例设计模式，包括饿汉式、懒汉式、双重检查锁、静态内部类和枚举方式的实现，以及如何解决序列化和反射带来的单例破坏问题。同时，通过JDK中的Runtime类展示了单例模式的实际应用。
摘要由CSDN通过智能技术生成

设计模式之单例模式

1 单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一 , 它提供了一种创建对象的最佳方式, 该类负责创建自己的对象，同时确保只有单个对象被创建, 提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象.

1 单例的结构

单例模式中主要是以下角色:

  • 单例类 只能创建一个实例的类
  • 访问类 使用单例类

2 单例的实现

1 饿汉式
1 方式1-静态变量
public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 在成员位置创建该类的对象
    private static Singleton instance = new Singleton();

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return instance;
    }
}

通过成员位置声明Singleton类型的静态变量,且创建类的对象, 该对象随着类的加载和创建. 没有被使用也会被创建,会造成浪费内存.

2 方式2-静态代码块
public class Singleton {

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

    // 在成员位置创建该类的对象
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return instance;
    }
}

通过成员位置声明Singleton类型的静态变量,而对象则是在静态代码块中创建, 该对象随着类的加载和创建. 没有被使用也会被创建,会造成浪费内存.

2 懒汉式
1 方式1- 线程不安全
public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 在成员位置创建该类的对象
    private static Singleton instance;

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {

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

在成员位置申明变量,在调用方法时创建类对象,且不为null时,直接返回该对象. 实现按需加载,可节省内存. 但是在多线程环境下,会出现问题.

即线程一,通过判断发现instance为null, 然后切换线程二执行,此时instance依然为null, 所以两个线程获取的对象不一致.

2 方式2-线程安全synchronized
public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 在成员位置创建该类的对象
    private static Singleton instance;

    // 对外提供静态方法获取该对象
    public static synchronized Singleton getInstance() {

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

在上述线程不安全的基础上, 直接在方法上添加synchronized锁,可以保证线程安全问题. 但是对该方法加锁,导致执行的效果很低, 后续线程都得等待前面执行完整个方法才执行.

3 方法3-双重检查锁
public class Singleton { 

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

    private static Singleton instance;

   // 对外提供静态方法获取该对象
    public static Singleton getInstance() {
		// 第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(instance == null) {
            synchronized (Singleton.class) {
                // 抢到锁之后再次判断是否为null
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，但在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作. 再加上volatile 关键字,就可解决问题,

volatile 关键字可以保证可见性和有序性,即防止JVM进行指令重排.

public class Singleton { 

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

    private static volatile Singleton instance;

   // 对外提供静态方法获取该对象
    public static Singleton getInstance() {
		// 第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(instance == null) {
            synchronized (Singleton.class) {
                // 抢到锁之后再次判断是否为null
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
4 方式4-静态内部类
public class Singleton {

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

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

第一次加载Singleton类是不会初始化对象, 只有第一次调用getInstance方法,JVM才会加载内部类SingletonHolder,并且初始化内部类静态变量,不仅可以保证线程安全,也保证唯一性.

tips: 静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费.

5 方式5-枚举方式
public enum Singleton {
    INSTANCE;
}

枚举类是极力推荐的单例实现模式，属于恶汉式, 因为枚举类型是线程安全的，并且只会装载一次 ,而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式.

3 存在的问题

枚举类型不会存在下面两个问题

破坏单例模式:

有两种方式，分别是序列化和反射

1 问题说明
1 序列化反序列化

Singleton类

public class Singleton implements Serializable {

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

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

Test类

public class Test {
    public static void main(String[] args) throws Exception {
        // 往文件中写对象
        // writeObject2File();
        // 从文件中读取对象
        Singleton s1 = readObjectFromFile();
        Singleton s2 = readObjectFromFile();

        // 判断两个反序列化后的对象是否是同一个对象
        System.out.println(s1 == s2);
    }

    private static Singleton readObjectFromFile() throws Exception {
        // 创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\a.txt"));
        // 第一个读取Singleton对象
        Singleton instance = (Singleton) ois.readObject();

        return instance;
    }

    public static void writeObject2File() throws Exception {
        // 获取Singleton类的对象
        Singleton instance = Singleton.getInstance();
        // 创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));
        // 将instance对象写出到文件中
        oos.writeObject(instance);
    }
}

// 运行结果 false

程序运行的结果是false, 说明破坏单例模式.

2 反射

Singleton类

public class Singleton {

    // 私有构造方法
    private Singleton() {}
    
    private static volatile Singleton instance;

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance != null) {
            return instance;
        }

        synchronized (Singleton.class) {
            if(instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

Test类

public class Test {
    public static void main(String[] args) throws Exception {
        // 获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        // 获取Singleton类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor();
        // 开启暴力反射
        constructor.setAccessible(true);

        // 创建Singleton类的对象s1
        Singleton s1 = (Singleton) constructor.newInstance();
        // 创建Singleton类的对象s2
        Singleton s2 = (Singleton) constructor.newInstance();

        // 判断通过反射创建的两个Singleton对象是否是同一个对象
        System.out.println(s1 == s2);
    }
}
// 结果  false

程序运行的结果是false, 说明破坏单例模式.

2 问题解决
1 序列化和反序列化问题

在类中添加readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象.

Singleton类

public class Singleton implements Serializable {

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

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    
    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return SingletonHolder.INSTANCE;
    }
}

具体原因, 是ObjectInputStream类代码底层,会去调用这个方法,如果存在就调用,否则就返回new出来的对象.

...
    
    
private Object readOrdinaryObject(boolean unshared) throws IOException {
	...
    obj = desc.isInstantiable() ? desc.newInstance() : null; 
    ...
    // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true
        // hasReadResolveMethod 就是判断是否存在该方法
    if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
    	Object rep = desc.invokeReadResolve(obj);
     	...
    }
    return obj;
}
...
2 反射问题
public class Singleton {

    // 私有构造方法
    private Singleton() {
        /*
           反射破解单例模式需要添加的代码
        */
        if(instance != null) {
            throw new RuntimeException();
        }
    }
    
    private static volatile Singleton instance;

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance != null) {
            return instance;
        }

        synchronized (Singleton.class) {
            if(instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

通过反射调用时,因为对象已经创建,直接抛出异常,防止通过反射创建对象.

4 JDK源码案例

JDK中Runtime类就是使用的单例设计模式.

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

    public static Runtime getRuntime() {
        return currentRuntime;
    }
}
韩_师兄
关注
专栏目录
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
c#设计模式之单例模式的实现方式
12-26
单例模式对于我们来说一点也不模式，是一个常见的名称，单例模式在程序中的实际效果就是：确保一个程序中只有一个实例，并提供一个全局访问点，节省系统资源 单例模式无论是在实际开发中还是在软件应用中比较常见，...
JAVA设计模式之单例模式
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
PHP语言设计模式之单例模式
低头赶路，敬事如仪
12-03 840
第1关：饿汉式
PHP设计模式之单例模式
单线程boy
04-24 626
单例设计模式(Singleton Design Pattern)的意思是：一个类只允许创建一个对象(或者实例)，那这个类就是一个单例类，这种设计模式就叫作单例模式。单例模式可以保证类的对象全局唯一。 “一个类只允许创建唯一一个对象”，那对象的唯一性的作用范围是什么呢? 是指线程内只允许创建一个对象，还是指进程内只允许创建一个对象? 答案是后者，也就是说，单例模式创建的对象是进程唯一的。
一文带你彻底搞懂设计模式之单例模式！！由浅入深，图文并茂，超超超详细的单例模式讲解！！
祝你身体健康，美满幸福
06-28 6134
本篇文章通过图文形式，由浅入深，详细讲解了设计模式中的单例模式的应用
设计模式之单例模式(C++)
翟天保的博客
02-09 2万+
介绍设计模式之单例模式
java设计模式之单例模式
liu_da_da的博客
06-23 1万+
java设计模式之单例模式
C# 设计模式之单例模式
鲤籽鲲的博客
07-31 1151
C# 设计模式之单例模式
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 1万+
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
C# 设计模式之单例模式归纳总结
08-30
C# 设计模式之单例模式是一种常用的设计模式，它限制了类的实例化，使得某个类只能有一个实例，并提供了一个全局访问点来访问该实例。本文将对单例模式的定义、优缺点、实现要点和适用性进行详细的讲解。 单例模式...
Android编程设计模式之单例模式实例详解
01-04
单例模式是应用最广的模式之一，也可能是很多初级工程师唯一会使用的设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的...
【设计模式】深入理解 Python 单例模式：从原理到实现
h1773655323的博客
10-15 1086
单例模式的目的是保证一个类在整个程序中只有一个实例存在。举个现实生活中的例子，假设有一个管理数据库连接的类，在程序运行的过程中，我们可能需要多次访问数据库，但为了避免频繁创建和销毁连接资源，我们希望所有的数据库操作都通过同一个连接完成。这时，单例模式就派上用场了。单例模式可以确保一个类有且只有一个实例被创建，并且提供一个全局访问该实例的方式。
【Java并发编程三】多线程案例（手撕单例模式，阻塞队列，定时器，线程池）
2203_75565612的博客
10-16 1159
定时器也是软件开发中的一个重要组件. 类似于一个 "闹钟". 达到一个设定的时间之后, 就执行某个指定好的代码。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取.上述代码还可以进行改进，加锁和解锁是一件开销比较高的事情. 而懒汉模式的线程不安全只是发生在首次创建实例的时候.因此后续使用的时候, 不必再进行加锁了.懒汉模式在类加载的时候不创建实例，第一次使用的时候才创建实例。
卡通风格化魔法术技能粒子特效 ：Toon Projectiles 2 1.0
最新发布
10-19
这款卡通射击特效资源包提供了 15 种独特的射击物、命中效果和闪光效果，风格统一且易于与您的项目集成。它默认支持 Unity 的内置渲染器，并且兼容 HDRP 和 URP 渲染管线。如果您拥有 Hovl Studio 的其他资源，该包将免费提供。所有效果均在各平台兼容，并且可以通过标准尺寸值轻松调整命中效果的大小。需要注意的是，调整射击物大小时，可能需要修改轨迹长度和按距离生成的速率。 该资源还包含了一个演示场景射击脚本，方便用户快速了解如何使用这些特效。该资源包还与 InfinityPBR 的 Projectile Factory 插件兼容，可以进一步增强您的射击游戏效果。 需要注意的是，推广媒体中使用的后处理效果 "Bloom" 并非资源包自带，建议用户在下载资源包之前，先行从 Unity 包管理器下载 "Post Processing Stack"。HDRP 和 URP 渲染管线的用户可以直接利用内置的 "Volume" 组件中的 "Bloom" 效果。
在 MATLAB GUI 中动态更新数据：策略与实践
10-19
通过本文的详细介绍，你应该能够理解如何在 MATLAB GUI 中更新数据。从设计 GUI 界面到处理用户输入，再到动态更新数据，每一步都是构建交互式 MATLAB 应用程序的关键。通过实际的代码示例，你可以更深入地理解这些概念，并将其应用到你自己的项目中。 记住，GUI 的设计和实现是一个迭代的过程。随着你对用户需求的更深入了解，你可能需要不断调整和优化你的 GUI。通过持续的测试和反馈，你可以创建一个既美观又功能强大的 MATLAB GUI 应用程序
Java设计模式之单例模式详解
单例模式（Singleton）是一种常用的设计模式，它的主要目的是确保一个类中只有一个实例，并且该实例必须自动创建，并向整个系统提供该实例。下面我们来详细了解单例模式的定义、结构、优缺点和应用场景。 定义： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值