【设计模式】你不了解的单例模式

约定不等于承诺〃 2022-09-05 05:30 217阅读 0赞

## 什么是单例模式？ ##

单例模式：一个类有且只能有一个对象（实例）。单例模式的 3 个要点：

1.  外部不能通过 new 关键字（构造函数）的方式新建实例，所以构造函数为私有：`private Singleton(){}`
2.  只能通过类方法获取实例，所以获取实例的方法为公有、且为静态：`public static Singleton getInstance()`
3.  实例只能有一个，那只能作为类变量的「数据」，类变量为静态 （另一种记忆：静态方法只能使用静态变量）：`private static Singleton instance`

## 实现单例模式的方法 ##

### 饿汉式 ###

public class Singleton1 { 
        private static Singleton1 instance = new Singleton1();
    
        private Singleton1(){ 
        }
    
        public static Singleton1 getInstance(){ 
            return instance;
        }
    }

### 懒汉式 ###

public class Singleton2 { 
        /* 代码 instance = new Singleton(); 会被计算机拆为 3 步执行。 * A：在堆中分配一块内存空间 * B：在内存空间位置新建一个实例 * C：将引用指向实例，即，引用存放实例的内存空间地址 * 线程可能按 ACB 执行，如果 instance 都在 synchronized 里面， * 怎么重排序都没啥问题。问题出现在还有 instance 在 synchronized 外边， * 因为此时外边一群饿狼（线程），就在等待一个 instance 这块肉不为 null。 * 模拟一下指令重排序的出错场景：多线程环境下，正好一个线程，在同步块中按 ACB 执行， * 执行到 AC 时（并将 instance 写回了主内存），另一个线程执行第一个判断时， * 从主内存拷贝了最新的 instance，认为 instance 不为空，返回 instance， * 但此时 instance 还没被正确初始化，所以出错。 * * volatile 修饰 instance 时，虚拟机在 ACB 后添加一个 lock 指令， * lock 指令之前的操作执行完成后，后面的操作才能执行。只有当 ACB 都执行完了之后， * 其他线程才能读取 instance 的值，即：只有当写操作完成之后，读操作才能开始。 * 这也是 Java 虚拟机规范的其中一条先行发生原则：对 volatile 修饰的变量，读操作， * 必须等写操作完成。所以用 volatile 修饰 instance，是使用它的禁止指令重排序特性： * 禁止读指令重排序到写指令之前。（它禁止不了 lock 指令前的指令重排序。） */
        private static volatile Singleton2 instance;
    
        private Singleton2(){ 
        }
    
        public static Singleton2 getInstance(){ 
            if(instance == null){ 
                synchronized(Singleton2.class) { 
                    if(instance == null) { 
                        instance = new Singleton2();
                    }
                }
            }
    
            return instance;
        }
    }

### 枚举方式 ###

public enum Singleton3 { 
        INSTANCE;
    }

### 静态内部类方式 ###

/* * 这种方式采用了类装载的机制来保证初始化实例时只有一个线程，静态内部类方式在外部类被加载时并不会 * 立即变例化，而是在需要实例化时，调用getSingleton方法，才会装载 Singleton内部类，从而完成 * 外部类的实例化。类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程 * 的安全性，在类进行初始化时，别的线程是无法进入的优点：避免了线程不安全，利用静态内部类的特点实 * 现延迟加载，效率高。 */
    public class Singleton4 { 
        private static class InstanceHolder{ 
            private static final Singleton4 INSTANCE = new Singleton4();
        }
        private Singleton4(){ 
        }
    
        public static final Singleton4 getInstance() { 
            return InstanceHolder.INSTANCE;
        }
    }

## 反射攻击 ##

### 如何进行反射攻击 ###

借助懒汉式双重验证的单例，通过反射可以绕过私有构造方法无法调用创建对象实例的限制，证明通过反射可以创建对象，从而是这种单例模式失效。

public class ReflectAttack { 
        public static void main(String[] args) throws IllegalAccessException, InvocationTargetException,     InstantiationException, NoSuchMethodException { 
            Singleton2 instance1 = Singleton2.getInstance();
            Class clazz = instance1.getClass();
            Constructor<Singleton2> constructor = clazz.getDeclaredConstructors()[0];
            constructor.setAccessible(true);
    
            Singleton2 instance2 = constructor.newInstance();
            System.out.println(instance1 == instance2);
        }
    }

### 如何避免反射攻击 ###

*  在懒汉式的写法中，构造函数里判断INSTANCE是否为空，不为空直接报错不允许创建。

public class Singleton5 { 
            private volatile static Singleton5 INSTANCE;
    
            private Singleton5() { 
                //如果已存在，直接抛出异常，保证只会被new 一次
                if (INSTANCE != null) { 
                    throw new RuntimeException("对象已存在不可重复创建");
                }
            }
    
            public static Singleton5 getInstance() { 
                if (INSTANCE==null){ 
                    //同步代码块
                    synchronized (Singleton5.class){ 
                        if (INSTANCE == null) { 
                            INSTANCE = new Singleton5();
                        }
                    }
                }
                return INSTANCE;
            }
        }

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

*  枚举的方式天然可以避免反射攻击

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

## 序列化攻击 ##

### 如何进行序列话攻击 ###

为了能够被序列化，Singleton2类需要实现接口Serializable，

public class SerializableAttack { 
        public static void main(String[] args) throws IOException, ClassNotFoundException { 
            Singleton2 instance = Singleton2.getInstance();
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton2"));
            oos.writeObject(instance);
            oos.flush();
            oos.close();
    
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Singleton2"));
            Singleton2 instance1 = (Singleton2) ois.readObject();
    
            System.out.println("序列化前后两个是否同一个："+(instance==instance1));
    
        }
    }

![在这里插入图片描述][bafb6b94ef634c2c8596a5b1c01d90e7.png_pic_center]

序列化前后两个对象并不相同，这样就导致单例模式失效了，进而进行相关攻击操作。至于为什么两个对象不同，是因为任何一个对象调用readObject方法，不管是显式的还是默认的，它都会返回一个新建的实例，这个新建的实例不同于该类初始化时创建的实例。

### 如何避免序列化攻击 ###

枚举方式实现单例对序列话攻击天然具有免疫能力。

public class SerializableAttack { 
        public static void main(String[] args) throws IOException, ClassNotFoundException { 
            Singleton3 instance2 = Singleton3.INSTANCE;
            ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream("Singleton3"));
            oos1.writeObject(instance2);
            oos1.flush();
            oos1.close();
    
            ObjectInputStream ois1 = new ObjectInputStream(new FileInputStream("Singleton3"));
            Singleton3 instance3 = (Singleton3) ois1.readObject();
    
            System.out.println("序列化前后两个是否同一个："+(instance2==instance3));
        }
    }

![在这里插入图片描述][8b78a81c2e0946dda6fb7a7798749dd4.png_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1dGlhbjcxMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/ba570131252046b8a24b1b2012086a94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1dGlhbjcxMw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/b648e07a15254a139b2618221d03dd4b.png
[bafb6b94ef634c2c8596a5b1c01d90e7.png_pic_center]: /images/20220829/9a1467ab92ab4900afd40a7c1646317b.png
[8b78a81c2e0946dda6fb7a7798749dd4.png_pic_center]: /images/20220829/e79f3cef885f4699b3dd8bc660d9e032.png