设计模式—单例模式 / DCL失效问题 / 暴力破解单例 (反射/序列化)

刺骨的言语ヽ痛彻心扉 2024-02-05 20:08 20阅读 0赞

##### [单例模式][Link 1] #####

*   *  杂谈
     *   *  前提
         *  饿汉模式：
         *  懒汉模式：
         *   *  线程不安全
             *  线程安全
         *  双重锁懒汉模式(Double Check Lock)
         *  静态内部类模式
         *  枚举单例

#### 杂谈 ####

和同学在聚会的时候聊起设计模式，聊完之后发现我对自己的设计模式的看法貌似存在误解，当我看到设计模式的外衣，我就误以为我已经发现了它的内在！  
原因是聊到—单例模式的时候，我就觉得，这有啥好讲的，不就是%&*&*……&%，那么简单吗，结果同学问了我 **DCL失效问题** 是什么？**静态内部类是线程安全**的吗？为什么？…然后，就没有然后了…

发现一篇贼六的博客，引用了~(中间加上点自己的观点，也顺便排版了一下，强迫症标识有点受不了博主的排版)，后续暴力破解单例为原创，可供大家参考。

[原文链接：https://blog.csdn.net/mnb65482/article/details/80458571][https_blog.csdn.net_mnb65482_article_details_80458571]

##### 前提 #####

首先我们要先了解下单例的四大原则：

1.  构造私有。
2.  以静态方法或者枚举返回实例。
3.  确保实例只有一个，尤其是多线程环境。
4.  确保反序列换时不会重新构建对象。

我们常用的单例模式有：

饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式，我们来逐一分析下这些模式的区别。

##### 饿汉模式： #####

public class SingleTon{
        
     	private static SingleTon INSTANCE = new SingleTon();
     	private SingleTon(){
        }
    	public static SingleTon getInstance(){
         return INSTANCE; }
    }
    12345

public class SingleTon{
          
        private SingleTon INSTANCE = null;  
        static {
          
        INSTANCE = new SingleTon();  
        }  
        private SingleTon(){
        }  
        public static SingleTon getInstance() {
          
        return this.INSTANCE ;  
        }  
    }
    12345678910

饿汉模式在类被初始化时就已经在内存中创建了对象，以空间换时间，故不存在线程安全问题。

##### 懒汉模式： #####

###### 线程不安全 ######

public class SingleTon{
        
       private static SingleTon  INSTANCE = null;
       private SingleTon(){
        }
       public static SingleTon getInstance() {
          
       if(INSTANCE == null){
        
          INSTANCE = new SingleTon(); 
        } 
        return INSTANCE；
      }
    }
    12345678910

###### 线程安全 ######

public class SingleTon{
          
        private static SingleTon INSTANCE = null;
        private SingleTon(){
        }  
        public static synchronized SingleTongetInstance() {
          
        if (INSTANCE == null) {
          
            INSTANCE  = new SingleTon();  
        }  
        return INSTANCE ;  
        }  
    } 
    12345678910

懒汉模式在方法被调用后才创建对象，以时间换空间，在多线程环境下存在风险

##### 双重锁懒汉模式(Double Check Lock) #####

public class SingleTon{
        
      private static SingleTon  INSTANCE = null;
      private SingleTon(){
        }
      public static SingleTon getInstance(){
        if(INSTANCE == null){
        
       synchronized(SingleTon.class){
        
         if(INSTANCE == null){
         
            INSTANCE = new SingleTon();
           } 
         } 
            return INSTANCE; 
        } 
      }
    }
    12345678910111213

DCL模式的优点就是，只有在对象需要被使用时才创建，第一次判断 INSTANCE == null为了避免非必要加锁，当第一次加载时才对实例进行加锁再实例化。这样既可以节约内存空间，又可以保证线程安全。但是，由于jvm存在乱序执行功能，DCL也会出现线程不安全的情况。具体分析如下：

INSTANCE  = new SingleTon(); 
    1

这个步骤，其实在jvm里面的执行分为三步：

1.  在堆内存开辟内存空间。
2.  在堆内存中实例化SingleTon里面的各个参数。
3.  把对象指向堆内存空间。

由于jvm存在乱序执行功能，所以可能在2还没执行时就先执行了3（CPU 是根据时间片段抢时间执行的），如果此时再被切换到线程B上，由于执行了3，INSTANCE 已经非空了，会被直接拿出来用，这样的话，就会出现异常。这个就是著名的DCL失效问题。

不过在JDK1.5之后，官方也发现了这个问题，故而具体化了 volatile （解决指令重排序的问题） 即在JDK1.6及以后，只要定义为private volatile static SingleTon INSTANCE = null;就可解决DCL失效问题。 volatile确保INSTANCE每次均在主内存中读取，这样虽然会牺牲一点效率，但也无伤大雅。

##### 静态内部类模式 #####

public class SingleTon{
        
      private SingleTon(){
        }
     
      private static class SingleTonHoler{
        
         private static SingleTon INSTANCE = new SingleTon();
     }
     
      public static SingleTon getInstance(){
        
        return SingleTonHoler.INSTANCE;
      }
    }
    1234567891011

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。

即当SingleTon第一次被加载时，并不需要去加载 SingleTonHoler，只有当 getInstance()方法第一次被调用时，才会去初始化 INSTANCE ,第一次调用 getInstance() 方法会导致虚拟机加载 SingleTonHoler 类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

那么，静态内部类又是如何实现线程安全的呢？首先，我们先了解下类的加载时机。  
类加载时机：JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。

1.  遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时，对应的java代码场景为：new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。
2.  使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。
3.  当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。
4.  当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的类)，虚拟机会先初始化这个类。
5.  当使用JDK 1.7等动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF\_getStatic、REF\_putStatic、REF\_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。
    
    这5种情况被称为是类的主动引用，注意，这里《虚拟机规范》中使用的限定词是"有且仅有"，那么，除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用的行列。

我们再回头看下 getInstance() 方法，调用的是 SingleTonHoler.INSTANCE，取的是SingleTonHole r里的 INSTANCE 对象，跟上面那个DCL方法不同的是，getInstance()方法并没有多次去new对象，故不管多少个线程去调用getInstance()方法，取的都是同一个INSTANCE对象，而不用去重新创建。

当getInstance()方法被调用时，SingleTonHoler才在SingleTon的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建，然后再被getInstance()方法返回出去，这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢？在《深入理解JAVA虚拟机》中，有这么一句话:

虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。

如果在一个类的()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执行()方法后，其他线程唤醒之后不会再次进入()方法。同一个加载器下，一个类型只会初始化一次。)，在实际应用中，这种阻塞往往是很隐蔽的。

故而，可以看出INSTANCE在创建过程中是线程安全的，所以说静态内部类形式的单例可保证线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

那么，是不是可以说静态内部类单例就是最完美的单例模式了呢？其实不然，静态内部类也有着一个致命的缺点，就是传参的问题，由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，例如Context这种参数，所以，我们创建单例时，可以在静态内部类与DCL模式里自己斟酌。

##### 枚举单例 #####

public class SingleTon{
        
    
        public static SingleTon getInstance() {
        
            return Elvis.INSTANCE.getInstance();
        }
    
        private enum Elvis {
        
            INSTANCE;
            private SingleTon singleton;
    
            Elvis() {
        
                singleton = new SingleTon();
            }
    
            private SingleTon getInstance() {
        
                return singleton;
            }
        }
    }
    12345678910111213141516171819

外部的调用方法

SingleTon.getInstance
    1

其实枚举的本质静态块创建了对象，而外部声明了对它的引用。

当一个Java类第一次被真正使用到的时候静态资源将会被初始化、Java类的加载和初始化过程都是线程安全的(因为虚拟机在加载枚举的类的时候，会使用ClassLoader的loadClass方法，而这个方法使用同步代码块保证了线程安全)。

枚举类实现单例模式是 effective java 作者极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

怎样破坏单例？反序列化会破坏单例！！！反射可以暴力破解单例！！！

普通的Java类的反序列化过程中，会通过反射调用类的默认构造函数来初始化对象。所以，即使单例中构造函数是私有的，也会被反射给破坏掉。由于反序列化后的对象是重新new出来的，所以这就破坏了单例。

一般单例模式可以在构造方法里面增加判断单例对象是否被创建，防止反射破解。

序列化就是说把内存中的状态通过转换成字节码的形式
    从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
    内存中状态给永久保存下来了
    
    反序列化
    讲已经持久化的字节码内容，转换为IO流
    通过IO流的读取，进而将读取的内容转换为Java对象
    在转换过程中会重新创建对象new
    12345678

核心可参考 ObjectInputStream.java

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5MDY0ODE1_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5MDY0ODE1_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5MDY0ODE1_size_16_color_FFFFFF_t_70 2]  
需要在单例里面重写readResolve方法，并且返回单例的对象就避免序列化破解单例了。  
但是重写readResolve方法只不过是覆盖了反序列化处来的对象，本质还是创建了两次，之前反序列化出来的对象会被GC回收。

Java中有明确规定，

> 枚举的序列化和反序列化是有特殊定制的。  
> 并且枚举是无法通过反射实现。

所以利用枚举能避免这个问题。

参考资料：  
《深入理解JAVA虚拟机》  
《Android源码设计模式解析与实战》  
《java虚拟机规范》

[Link 1]: https://so.csdn.net/so/search?q=%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F&spm=1001.2101.3001.7020
[https_blog.csdn.net_mnb65482_article_details_80458571]: https://blog.csdn.net/mnb65482/article/details/80458571
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5MDY0ODE1_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/db6ce179173a476f9010078a83847063.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5MDY0ODE1_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/5abdedc7b6c94447a3124758d50ffe37.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5MDY0ODE1_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/fc72a001685e4e7bb7c7910a67b341e7.png