玩转单例模式（5种方式手写单例模式，反射破坏单例模式，写出反射破坏不了的单例模式，enum没法被反射破坏掉，单例模式你真的玩明白了么）

最新推荐文章于 2021-10-21 17:41:51 发布
最新推荐文章于 2021-10-21 17:41:51 发布
阅读量442 收藏 2
点赞数 2
分类专栏： 设计模式 文章标签： 设计模式 java 反射 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44861708/article/details/113824128
版权

玩转单例模式（先看前言）

前言

因为今年7月份要出去找校招工作，听在大厂的学长学姐们说，面试官关于设计模式会问，除了单例模式和工厂模式，你还会什么模式，嘿嘿。但是今天我先不搞其他设计模式，先把单例模式搞得明明白白的，再扯其他的模式，希望大家看完我写的这篇单例模式后能对单例模式有一个非常清楚的了解，所以希望大家耐心的看下去。所以这篇文章我会讲以下几点

  • 单例模式几种创建方式
    • 饿汉式
    • 懒汉式
    • DCL懒汉式（双重检测锁懒汉式）
    • 静态内部类
    • 枚举型
  • 使用反射破坏我们手写的单例模式
  • 再写出反射也不会破坏的单例模式
  • 为什么enum（枚举）类型的单例模式不会被反射破坏

一、单例模式的几种创建方式（由简单到复杂）

一说到单例模式，最起码得知道两种方式吧，一是饿汉式 ，二是懒汉式

1. 先说说饿汉式（是最简单的单例模式的实现）

饿汉式就是当类加载的时候就实例化，并且创建单例对象

步骤：
  1. 创建一个类，类里面声明一个静态的类的变量并实例化它
  2. 写一个获取该实例的方法
    上代码
public class Hungry {

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }

}
饿汉式的缺点：

饿汉式在类加载的时候就初始化，不管你是否使用，它都实例化了，所以会占据空间，浪费内存。
但如果我们为了节省内存空间，想要在什么时候需要这个单例对象什么时候实例化，应该怎么做呢，由此我们想出了懒汉式这种单例模式

2.谈谈最简单的懒汉式

为了解决不管你是否使用这个单例对象，它都实例化了，所以会占据空间，浪费内存的问题，我们就让这个单例对象只在第一次被使用的时候创建出来。
步骤：

  1. 创建一个类，类里面声明一个静态的类的变量
  2. 创建一个私有的构造器
  3. 写一个获取该实例的方法
    上代码
/**
 *  1.创建一个类，类里面声明一个静态的类的变量
 */
public class LazyMan {
    public static LazyMan LAZYMAN;

    // 2.创建一个私有的构造器
    private LazyMan(){

    }

    // 3.写一个获取该实例的方法
    public static LazyMan getInstance() {
    	// 判断该单例对象是否是第一次调用，如果是第一次就实例化出来
        if (LAZYMAN == null){
            LAZYMAN = new LazyMan();
        }
        return LAZYMAN;
    }
}
测试：
// 在多线程的情况下测试单例模式
public static void main(String[] args) {
        Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName() + ":" + LazyMan.getInstance());
        };
        new Thread(runnable,"A").start();
        new Thread(runnable,"B").start();
        new Thread(runnable,"C").start();
    }

多线程情况下跑我们的程序，单例模式不在单例

问题：

我通过这个代码虽然写出了懒汉式，但是我的这段代码只有在单线程的时候在是安全的，当我们的程序多线程工作时，可能会出现这个对象被创建了多次，单例模式不再单例（多次几次，真的会出现创建了多个对象的情况），一个程序只能有一个单例对象，如果它被多次创建，还是单例对象吗，所以为了解决这个问题，我们引出了下面的DCL懒汉式。

3.DCL懒汉式（Double Check Lock懒汉式，双重检测锁懒汉式）

为了在多线程的情况下，还用懒汉式只创建一个单例对象，我们应该怎么做？
好做，不就是多线程嘛，加锁就完事了，一提到多线程，你就得想到一件事加锁,所以我们想出了双重检测锁的懒汉式

步骤：
  1. 创建一个类，类里面声明一个静态的类的变量
  2. 创建一个私有的构造器
  3. 写一个获取该实例的方法（在这个方法上我们要做一些文章）
    1. 首先判断该实例是否存在，
    2. 如果不存在，去实例化一个对象，但是实例化对象的这段代码要加锁。
    3. 最后返回单例对象

上代码

// 1.创建一个类，类里面声明一个静态的类的变量
public class DCLlazyMan {
    public static DCLlazyMan DCLLAZYMAN;

//    2.创建一个私有的构造器
    private DCLlazyMan(){

    }

//    3.写一个获取该实例的方法
    // 双重检测锁模式的 懒汉式单利 DCL懒汉式
    public static DCLlazyMan getInstance(){
        //首先判断该实例是否存在
        if (DCLLAZYMAN == null){
            // 如果不存在，去实例化一个对象，但是实例化对象的这段代码要加锁。
            synchronized (DCLlazyMan.class){
                // 再次判断该实例是否存在，这个双重检测锁我感觉有点像乐观锁
                if (DCLLAZYMAN == null){
                    DCLLAZYMAN = new DCLlazyMan();
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     */
                }
            }
        }
        // 最后返回单例对象	
        return DCLLAZYMAN; // 可能出现指令重排，导致DCLLAZYMAN可能还没有完成构造 //解决方案：加volatile
    }
}
问题（最少三个问题）

  1. 问什么要检测两次单例对象是否为空？
    回答：这个问题还真有点不好描述，举个例子，现在两个线程，线程A和线程B,线程A执行到了这行代码if (DCLLAZYMAN == null){的时候休眠了，这时线程B也执行到了这行代码if (DCLLAZYMAN == null){并且一直执行下去，实例化了一个对象，然后线程B进行阻塞，线程A运行，这时如果我们不进行第二次检测，就会出现单例对象被实例化多次的现象（因为线程B已经实例化了单例对象），所以这就使我们问什么要使用双重检测锁

  2. 这个DCL懒汉式真的没问题吗？
    回答：有问题，最起码还有两个问题

    1. 不知大家是否听过一个神奇的名词叫做指令重排，就是java会为了优化代码会对你的代码顺序进行重排，什么意思呢？就是jvm执行的代码不一定是完全按照你写的代码去执行，恐怖吗，嘿嘿，当然人家的重排也是有一定的逻辑的，有兴趣的小伙伴可以去了解了解。为什么说这个事情，先问大家一个问题，DCLLAZYMAN = new DCLlazyMan();这行代码是一个原子操作吗，显而易见不是呀，我都能看到它这一行代码起码作了三步操作，

      1. 分配内存空间
      2. 执行构造方法，初始化对象
      3. 把这个对象指向这个空间

      我们理想中的代码执行顺序是这个123，但是指令重排可能会让我们的代码执行顺序变成132，这个是完全可以做到的（不明白的小伙伴去了解一下指令重排），那当我们的代码执行顺序变成132的时候，会不会出现这种情况：还是两个线程，线程A和线程B，线程A执行getInstance()方法，然后当我执行到这行代码DCLLAZYMAN = new DCLlazyMan();并且这行代码的执行顺序是132，当我执行到3的时候，线程A睡眠了，此时DCLLAZYMAN已经不在是一个NULL（虽然还没有构造完成），此时线程B也执行这个方法getInstance(),的时候，返回了判断DCLLAZYMAN不为null，然后返回了这个对象，但是我们出现了一个问题，就是这个对象不完整，是残缺的，对不对
      解决方案：禁止重排，使用volatile关键字禁止重排。(volatile关键字有三个特点：1.保证可见性；2，不保证原子性；3.禁止指令重排)

  3. 其实还有第三个问题，反射还是可以破解这个单例模式的，这个问题放在下面讲，先留个悬念

    如今的代码

// 1.创建一个类，类里面声明一个静态的类的变量
public class DCLlazyMan {
    
    // 使用volatile禁止指令重排
    public volatile static DCLlazyMan DCLLAZYMAN;

//    2.创建一个私有的构造器
    private DCLlazyMan(){

    }

//    3.写一个获取该实例的方法
    // 双重检测锁模式的 懒汉式单利 DCL懒汉式
    public static DCLlazyMan getInstance(){
        //首先判断该实例是否存在
        if (DCLLAZYMAN == null){
            // 如果不存在，去实例化一个对象，但是实例化对象的这段代码要加锁。
            synchronized (DCLlazyMan.class){
                // 再次判断该实例是否存在，这个双重检测锁我感觉有点像乐观锁
                if (DCLLAZYMAN == null){
                    DCLLAZYMAN = new DCLlazyMan();
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     */
                }
            }
        }
        return DCLLAZYMAN; // 可能出现指令重排，导致DCLLAZYMAN可能还没有完成构造 //解决方案：加volatile
    }
}
4.使用静态内部类实现单例模式（纯属炫技，没什么用）

步骤：

  1. 创建一个类并在创建一个内部类

直接上代码喽

/**
 * 1.创建一个类并在创建一个内部类
 */
public class Holder {
    private Holder(){

    }
    // 3. 写一个getInstance（）方法返回单例对象
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
    	// 2.在内部类中定义一个实例化出来一个单例对象
        private static final Holder HOLDER = new Holder();
    }
}
5.使用枚举类创建单例模式（现在实现单例模式最常用的方式）

枚举类实现单例模式太简单了，直接上代码

public enum  EnumSingle {
    INSTANCE;
    public static EnumSingle getInstance() {
        return INSTANCE;
    }
}

完事了。

枚举类创建单例模式的好处
  • 1.既是懒汉式，还足够简单
  • 2.反射破坏不了我们的单例模式（下面讲为什么反射破坏不了我们用enum实现的单例模式）

二、反射破坏单例模式

如果只是实现了我上面所述的DCL懒汉式，就可以完美实现单例模式，那就大错特错了，有没有人想到用Java的反射来破解单例模式，我这就来用反射破坏我实现的DCL懒汉式

上代码
// 用反射破坏单例模式
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//		输出单例对象    
        System.out.println(DCLlazyMan.getInstance());
//		使用反射创建出来DCLlazyMan的实例化对象
        Constructor<DCLlazyMan> declaredConstructor = DCLlazyMan.class.getDeclaredConstructor(null);
        // 设置让变量的访问控制修饰符无效（private，default，protected，public）
        declaredConstructor.setAccessible(true);
        // 输出通过反射创建的对象
        DCLlazyMan dcLlazyMan = declaredConstructor.newInstance();
        System.out.println(dcLlazyMan);

    }
输出结果：不是一个对象（完犊子，DCL懒汉式被破坏了）

在这里插入图片描述

怎么办

在单例类中定义一个非当前对象（随便定义一个变量，boolean类型，默认false,这个变量是其他人看不到的）来作为标志位，在构造方法中进行判断。这个标志位在反射创建对象时是完全不知道的
上代码

// 1.创建一个类，类里面声明一个静态的类的变量
public class DCLlazyMan {
    // 定义的是我的博客名字
    private static boolean taomewhy = false;
    // 使用volatile禁止指令重排
    public volatile static DCLlazyMan DCLLAZYMAN;

//    2.创建一个私有的构造器
    private DCLlazyMan(){
        synchronized (DCLlazyMan.class){
            if (taomewhy == false){
                taomewhy = true;
            }else {
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }

//    3.写一个获取该实例的方法
    // 双重检测锁模式的 懒汉式单利 DCL懒汉式
    public static DCLlazyMan getInstance(){
        //首先判断该实例是否存在
        if (DCLLAZYMAN == null){
            // 如果不存在，去实例化一个对象，但是实例化对象的这段代码要加锁。
            synchronized (DCLlazyMan.class){
                // 再次判断该实例是否存在，这个双重检测锁我感觉有点像乐观锁
                if (DCLLAZYMAN == null){
                    DCLLAZYMAN = new DCLlazyMan();
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     */
                }
            }
        }
        return DCLLAZYMAN; // 可能出现指令重排，导致DCLLAZYMAN可能还没有完成构造 //解决方案：加volatile
    }

    // 用反射破坏单例模式
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        System.out.println(DCLlazyMan.getInstance());
        Constructor<DCLlazyMan> declaredConstructor = DCLlazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        DCLlazyMan dcLlazyMan = declaredConstructor.newInstance();
        System.out.println(dcLlazyMan);

    }
}

三、为什么enum实现的单例模式没有办法破坏掉

试试反射能不能破坏用enum实现的单例模式

先用反射试试，才能知道能不能破坏
上代码

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//		输出单例对象 
        System.out.println(EnumSingle.INSTANCE);
//		使用反射创建出来DCLlazyMan的实例化对象
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor();
        // 设置让变量的访问控制修饰符无效（private，default，protected，public）
        declaredConstructor.setAccessible(true);
        // 输出通过反射创建的对象
        EnumSingle enumSingle = declaredConstructor.newInstance();
        System.out.println(enumSingle);
    }
}

结果如下：

没有这个构造方法
没有这个构造方法？？？，为什么？
反射创建对象时传的参数不够，不然不应该是报这个错误，为什么，我们来扒一波源码，首先我们是用Constructor类newInstance()方法的来创建对象,我们点进去看一下源码发现
Constructor类newInstance()
所以我们是反射创建对象时传的参数不够，我们来反编译一下，我们的class文件
步骤，在自己写的类的所在目录下打开dos窗口，然后使用javap -p 你的class文件反编译class文件
反编译返现有这个空参构造方法，可运行解决却报错没有，所以我们反编译的代码有问题，所以我们用一个更专业的反编译软件jda.exe
想要下载jad的小伙伴点下方的连接
百度网盘jad链接：https://pan.baidu.com/s/1j3-q36EHxGOIkiL1qL-VlA：
提取码：x4gt
使用jad步骤，把下载的jad放在自己写的类的所在目录下，然后打开dos窗口，
此刻当前目录下多了一个使用jad文件反编译出来的java类，打开java类

package single;


public final class EnumSingle extends Enum
{

    public static EnumSingle[] values()
    {
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(single/EnumSingle, name);
    }

    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public static EnumSingle getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
            INSTANCE
        });
    }
}

这是反编译出来的枚举类，发现不是一个空参的构造方法，所以我们改造我们的反射实例化的程序的代码，传入两个参数,改造如下

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        System.out.println(EnumSingle.INSTANCE);
        // 就多传两个参数String.class,int.class,切记不要穿Integer.class,int和Integer不是一个玩意
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle enumSingle = declaredConstructor.newInstance();
        System.out.println(enumSingle);
    }
}

然后再执行测试代码，报错，不能通过反射创建枚举类，跟我们在Constructor类newInstance()方法中看到的抛出的异常完全一样。石锤，enum创建的单例模式没办法用反射破坏掉。
在这里插入图片描述

四、其他

补充一些小知识，反编译出来的代码可能跟你写的代码有一点出入，毕竟是被优化过的代码，但是实现的功能完全一样。

ぃ陌上烟雨
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java中如何创建一个不会被反射破坏的单例
ForteScarlet's Blog
06-15 991
前言 单例相信各位都不陌生，从学习java开始就会经常接触到这个概念，首先先来回忆一下什么是单例： 单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去...
Java23种设计模式之单例模式的五种实现方式、反射破解单例模式、不能破解枚举单例模式详解
热门推荐
weixin_43246215的博客
07-24 2万+
目录设计模式简介单例模式的简介单例模式的实现实现方式一：饿汉式（单例对象立即加载）实现方式二：懒汉式（单例对象延迟加载）实现方式三：双重检测锁实现（不建议使用）实现方式四：静态内部类实现方式(懒加载方式)实现方式五：枚举单例模式总结 设计模式简介 将设计者的思维融入大家的学习和工作中，更高层次的思考！ • 创建型模式： – 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。 • 结构型模式： – 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 • 行为型模式： – 模版方法模
单例模式详解--通过源码分析：反射及反序列化破坏单例原理及枚举式单例如果防止其破坏、readResolve()如何防止反序列化破坏单例以及spring容器式单例思想
a_higher的博客
11-14 437
本文转载：https://blog.csdn.net/weixin_49176063/article/details/107299195?utm_medium=distribute.wap_relevant.none-task-blog-title-6 单例模式详解--通过源码分析：反射及反序列化破坏单例原理及枚举式单例如果防止其破坏、readResolve()如何防止反序列化破坏单例以及spring容器式单例思想 写在前面 本文从最基础的饿汉式及懒汉式demo进行引入，通过jdk源码分别分析了：反射
利用反射机制破坏单例（1）
Kenny的博客
08-02 774
前言 今天突然有个想法，既然单例类通过私有化构造函数来实现单例，而java中通过反射可以获取类中任意的属性和方法，那么可以利用java反射机制获取单例类的私有构造函数来实例化对象，从而获取到新的对象。下面用代码进行实践。 代码实现 单例类 Singleton ： public class Singleton { private static Singleton singleton ...
Java单例模式实现的几种方式
09-01
Java单例模式是一种设计模式，它保证一个类只有一个实例，并提供一个全局访问点。这种模式在需要频繁创建和销毁对象的场景中非常有用，比如配置类、缓存管理或者数据库连接池等。以下是对Java中实现单例模式的几种...
jiangzhuqingfeng#BestNote#单例模式的四种实现方式1
07-25
枚举模式public enum Singleton3 {Holder模式public class Singleton4 {* 类级内部类，也就是静态的成员内部类
使用单例模式创建学生管理系统（饿汉式、懒汉式）
04-28
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。在Java或类似的面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。在这个...
java单例模式4种使用方式分享
09-04
在Java中，有多种实现单例模式的方式，下面详细介绍四种常见的Java单例模式实现。 1. **静态内部类（SingletonHolder）** 这种方式在《Java Concurrency In Practice》一书中被推荐。其主要优点是线程安全且延迟...
ava常用设计模式-单例模式
最新发布
08-26
单例模式有多种实现方式，以下是四种常见的实现方式： 1. 饿汉式 饿汉式是最简单的单例模式实现方式。其优点是没有加锁，执行效率会提高。但是，它的缺点是类加载时就初始化，浪费内存。 ``` public class ...
单例设计模式及反射机制破坏
SeeYourself的博客
07-19 386
概念： 　　Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。 　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。 一.下面为大家介绍两种
设计模式之单例模式，六种实现，以及反射破解
Wu_Shang001的博客
08-15 165
在介绍设计模式之前，先贴一下设计模式的三种类型，和六大原则。 创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 设计模式的六原则 开闭原则：对扩展开放,对修改关闭 里氏代换原则：任何基类可以出现的地方,子类一定可以出现,(子类
为什么要用枚举实现单例模式（避免反射、序列化问题）
他
04-06 175
为什么要用枚举实现单例模式（避免反射、序列化问题）
单例设计模式，详细到爆炸！（包括反射机制破解单例）
Brath的博客
09-10 248
单例设计模式： 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。 作用：让一个类只能创建一个实例（因为频繁的创建对象，
设计模式：单例模式（反射破坏，枚举不能被破坏的原因）
weixin_42740540的博客
10-21 924
除了枚举单例，其余都能被反射破坏。 双重检查+懒汉式+私有构造判断（这已经是比较安全的写法，网上说不能破坏）： package com.yuanping.sjms_demo.singleton; /** * 单例模式标准，私有静态成员变量，私有构造方法，公共静态获取实例的方法 */ public class DoubleCheck { private static volatile DoubleCheck doubleCheck = null; //volitile防止指令重排序
枚举单例模式如何防止反射攻击
01-04 896
关于单例模式，相信大家都所有了解，比较经典的实现有饿汉式、借助内部类、双重锁检测，这些实现可以保证线程安全，但是在某些特殊情况下并不能够保证仅仅只有一个单例，因为像序列化、反射攻击等往往可以生成新的实例对象，本文将重点分析枚举单例模式如何防止反射攻击。 枚举单例： public enum Singleton { INSTANCE { @Override
java 反射 单例类_java单例模式详解完美实现(包括反射破坏的防止和线程安全)
weixin_33421065的博客
02-16 466
一.描述Singleton(单例)是设计模式的一种,为了保证一个类仅有一个实例，并提供一个访问它的全局访问点。主要用途是保证某个很占系统资源的类，在同一时间只能拥有一个的情况。例如：一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。二.单例模式的主要特点：1.某个类只能有一个实例；2.必须自行创建这...
JUC详解-17-单例模式- 四种实现方式&反射破坏及解决办法
baidu_38126306的博客
11-22 724
JUC详解 -> 单例模式 - 四种实现方式&反射破坏及解决办法 Volatile --> 单例模式！ 饿汉式 DCL懒汉式 枚举为什么可以避免单例模式被破坏？ 1. 什么是单例模式 当需要某个类只能被实例化一次的时候，就要使用单例模式。 单例模式是比较简单的一种设计模式。 一个类如何才能只被实例化一次？ 一般实例化对象时，都会调用类的构造方法，因此将该类的构造方法private，就不能向外界提供，即保证了该类对象的唯一性。但这样的话，就无法调用这个类的构造方法了，也就无法实例化
Java 反射机制（二）使用反射破坏单例，使用枚举加强单例
阿凯的专栏
01-11 1488
本文介绍了如何使用反射机制破坏传统的单例类，以及如何使用Java的枚举类创造出最简捷，最安全的单例。 反射的功能非常强大，普通的单例，将默认的无参构造方法私有化，但是利用反射机制任然可以实现对私有构造器的访问，实例化出多个对象。 1. 新建一个懒汉模式的单例类 SingleTonUtils.java /** * */ package com.jnk.think.java.chapt
Sring单例模式，用什么可以破坏他的单例
07-25
3. 使用enum：使用enum来实现单例模式可以防止通过反射和序列化破坏单例。 需要注意的是，Spring框架本身提供了对单例模式的管理和控制，可以通过配置文件或注解的方式来确保单例的创建和管理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值