创建型模式【1】——单例模式

蔚落 2023-02-10 08:08 198阅读 0赞

> [https://blog.csdn.net/qq\_40794973/article/details/104165984][https_blog.csdn.net_qq_40794973_article_details_104165984]

>  *  **定义** : 保证一个类仅有一个实例，并提供一个全局访问点
>  *  **类型** : 创建型
>  *  **适用场景** : 想确保任何情况下都绝对只有一个实例
>  *  **优点** : 在内存里只有一个实例，减少了内存开销；可以避免对资源的多重占用；设置全局访问点，严格控制访问
>  *  **缺点** : 没有接口，扩展困难
>  *  **重点** : 私有构造器；线程安全；延迟加载；序列化和反序列化安全；反射

--------------------

# 1 懒汉式（线程不安全）\[不可用\]  #

> 在多线程模式下，懒汉式由于线程不安全是不可用的

public class Singleton {
        private static Singleton instance;
        //私有化构造器
        private Singleton() {
            try {
                //创建对象 耗时操作
                TimeUnit.SECONDS.sleep(new Random().nextInt(5));
            } catch (InterruptedException ignored) {}
        }
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

@Test
    public void testThreadVis() throws IOException {
        Runnable task = () -> {
            Singleton instance = Singleton.getInstance();
            System.out.println(Thread.currentThread().getName() + "  " + instance);
        };
        new Thread(task, "线程一").start(); //线程一  Singleton@46385f83
        new Thread(task, "线程二").start(); //线程二  Singleton@4ef99cce
        System.in.read();
    }

--------------------

# **2 **反序列化破坏单例模式 #

/**
     * 饿汉式（静态常量）
     */
    //这个单例类实现了序列化接口
    public class Singleton implements Serializable {
        private final static Singleton instance = new Singleton();
        // 构造函数私有化
        private Singleton() {}
        public static Singleton getInstance() {
            return instance;
        }
    }

//反序列化破坏单例模式
    @Test
    public void test() throws IOException, ClassNotFoundException {
        Singleton instance = Singleton.getInstance();
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
        oos.writeObject(instance);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("singleton_file")));
        Singleton deserializationObj = (Singleton) ois.readObject();
        System.out.println(instance); // Singleton@5e8c92f4
        System.out.println(deserializationObj); // Singleton@244038d0
    }

--------------------

# 3 readResolve 避免反序列化 #

/**
     * 饿汉式（静态常量）
     */
    //这个单例类实现了序列化接口
    public class Singleton implements Serializable {
        private final static Singleton instance = new Singleton();
        // 构造函数私有化
        private Singleton() { }
        public static Singleton getInstance() {
            return instance;
        }
        //
        private Object readResolve(){
            return instance;
        }
    }

//声明readResolve方法，防止反序列化破坏单例模式
    @Test
    public void test() throws IOException, ClassNotFoundException {
        Singleton instance = Singleton.getInstance();
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
        oos.writeObject(instance);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("singleton_file")));
        Singleton deserializationObj = (Singleton) ois.readObject(); //打断点
        System.out.println(instance); // Singleton@5e8c92f4
        System.out.println(deserializationObj); // Singleton@5e8c92f4
        System.out.println(instance == deserializationObj);
    }

//java.io.ObjectInputStream#readObject
    public final Object readObject() {
        if (enableOverride) {
            return readObjectOverride();
        }
        // if nested read, passHandle contains handle of enclosing object
        int outerHandle = passHandle;
        try {
            Object obj = readObject0(false); //打断点
    //java.io.ObjectInputStream#readObject0
    private Object readObject0(boolean unshared) throws IOException {
        try {
            switch (tc) {
                case TC_OBJECT:
                    return checkResolve(readOrdinaryObject(unshared)); //打断点
    //java.io.ObjectStreamClass#invokeReadResolve
    private Object readOrdinaryObject(boolean unshared) {
        Object obj;
        try {
            //创建对象
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {}
        if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
            //反射调用readResolve方法
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                // Filter the replacement object
                if (rep != null) {
                    if (rep.getClass().isArray()) {
                        filterCheck(rep.getClass(), Array.getLength(rep));
                    } else {
                        filterCheck(rep.getClass(), -1);
                    }
                }
                handles.setObject(passHandle, obj = rep);
            }
        }
        return obj;
    }

--------------------

# 4 反射破坏单例模式 #

public class Singleton {
        private final static Singleton instance = new Singleton();
        // 构造函数私有化 反射可以破坏
        private Singleton() {}
        public static Singleton getInstance() {
            return instance;
        }
    }

@Test
    public void test() throws Exception {
        Singleton instance = Singleton.getInstance();
        Class<Singleton> objClass = Singleton.class;
        Constructor<Singleton> constructor = objClass.getDeclaredConstructor();
        constructor.setAccessible(true); //java.lang.IllegalAccessException: Class SingletonTest can not access a member of class Singleton with modifiers "private"
        Singleton reflexObj = constructor.newInstance();
        //
        System.out.println(instance); //Singleton@32a1bec0
        System.out.println(reflexObj); //Singleton@22927a81
        System.out.println(reflexObj == instance); //false
    }

--------------------

# 5 反射防御 #

public class Singleton {
        private final static Singleton instance = new Singleton();
        // 构造函数私有化
        private Singleton() {
            //反射防御 只有饿汉式、静态内部类 才可用
            if (instance != null) {
                throw new RuntimeException("单例构造器禁止反射调用");
            }
        }
        public static Singleton getInstance() {
            return instance;
        }
    }

public class Singleton {
        private Singleton() {
            if (SingletonInstance.INSTANCE != null) {
                throw new RuntimeException("单例构造器禁止反射调用");
            }
        }
        private static class SingletonInstance {
            private static final Singleton INSTANCE = new Singleton();
        }
        public static Singleton getInstance() {
            return SingletonInstance.INSTANCE;
        }
    }

--------------------

# 6 反射防御失败 #

/**
     * 懒汉式（线程安全）（不推荐）
     */
    public class Singleton {
        private static Singleton instance;
        private Singleton() {
            if (instance != null) {
                throw new RuntimeException("单例构造器禁止反射调用");
            }
        }
        public synchronized static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

@Test
    public void test() throws Exception {
        Class<Singleton> objClass = Singleton.class;
        Constructor<Singleton> constructor = objClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        //如果反射方法先执行，依然是会有两个不同的对象的
        Singleton reflexObj = constructor.newInstance();
        Singleton instance = Singleton.getInstance();
        System.out.println(instance); // Singleton@32a1bec0
        System.out.println(reflexObj); // Singleton@22927a81
        System.out.println(reflexObj == instance); //false
    }

> 可能你想到用可以变量来标记私有化构造器执行了几次，然后在决定是否抛出异常，但是反射既然能执行私有化构造器那么也能直接该变你的标记值，对于lazy的单例模式反射破坏单例是无法有效防御的

public class Singleton {
        private static Singleton instance;
        private static boolean flag = true;
        private Singleton() {
            //在复杂的逻辑都是卵的
            if (flag) {
                flag = false;
            } else {
                throw new RuntimeException("单例构造器禁止反射调用");
            }
        }
        public synchronized static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

//通过反射来破坏lazy类型的单例模式，是无法有效避免的
    @Test
    public void test() throws Exception {
        Singleton instance = Singleton.getInstance(); //
        Class<Singleton> objClass = Singleton.class;
        Constructor<Singleton> constructor = objClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        //修改字段的值
        Field flag = objClass.getDeclaredField("flag");
        flag.setAccessible(true);
        flag.set(instance, true);
        Singleton reflexObj = constructor.newInstance();
        System.out.println(reflexObj); //Singleton@22927a81
        System.out.println(instance); //Singleton@78e03bb5
        System.out.println(reflexObj == instance); //false
    }

--------------------

# 7 完美的单例模式 #

## 7.1 枚举能够防止序列化破坏 ##

public enum EnInstance {
        //
        INSTANCE;
        private Object data;
        public Object getData() {
            return data;
        }
        public void setData(Object data) {
            this.data = data;
        }
        public static EnInstance getInstance() {
            return INSTANCE;
        }
    }

@Test
    public void test() throws IOException, ClassNotFoundException {
        //反序列化
        EnInstance instance = EnInstance.getInstance();
        //
        instance.setData(new Date());
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
        oos.writeObject(instance);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("singleton_file")));
        EnInstance deserializationObj = (EnInstance) ois.readObject();
        System.out.println(instance.getData()); // Fri May 22 11:15:50 CST 2020
        System.out.println(deserializationObj.getData()); // Fri May 22 11:15:50 CST 2020
        System.out.println(instance == deserializationObj);//true
    }

//java.io.ObjectInputStream#readEnum
    private Enum<?> readEnum(boolean unshared) throws IOException {
        String name = readString(false);
        Enum<?> result = null;
        Class<?> cl = desc.forClass();
        if (cl != null) {
            try {
                //拿到的是唯一的
                Enum<?> en = Enum.valueOf((Class)cl, name);

## 7.2 枚举能够防止反射破坏 ##

//java.lang.Enum
    //枚举只有唯一的构造器
    //protected Enum(String name, int ordinal) {
    //    this.name = name;
    //    this.ordinal = ordinal;
    //}
    @Test
    public void test() throws Exception {
        Class<EnInstance> objClass = EnInstance.class;
        Constructor<EnInstance> constructor = objClass.getDeclaredConstructor(String.class, int.class);
        constructor.setAccessible(true);
        EnInstance reflexObj = constructor.newInstance("乔碧萝", 58); //java.lang.IllegalArgumentException: Cannot reflectively create enum objects
        //java.lang.reflect.Constructor.newInstance
        //public T newInstance(Object ... initargs) {
        //	//如果是枚举是不允许反射创建对象的
        //	if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        //		throw new IllegalArgumentException("Cannot reflectively create enum objects");
    }

> [https://varaneckas.com/jad/][https_varaneckas.com_jad]

//jad EnInstance.class
    public final class EnInstance extends Enum {
        public static EnInstance[] values(){
            return (EnInstance[])$VALUES.clone();
        }
        public static EnInstance valueOf(String name){
            return (EnInstance)Enum.valueOf(EnInstance, name);
        }
        //构造器私有
        private EnInstance(String s, int i){
            super(s, i);
        }
        public Object getData(){
            return data;
        }
        public void setData(Object data){
            this.data = data;
        }
        public static EnInstance getInstance(){
            return INSTANCE;
        }
        //静态类变量
        public static final EnInstance INSTANCE;
        private Object data;
        private static final EnInstance $VALUES[];
        static 
        {
            INSTANCE = new EnInstance("INSTANCE", 0);
            $VALUES = (new EnInstance[] {
                INSTANCE
            });
        }
    }

[https_blog.csdn.net_qq_40794973_article_details_104165984]: https://blog.csdn.net/qq_40794973/article/details/104165984
[https_varaneckas.com_jad]: https://varaneckas.com/jad/