不一样的单例模式

女爷i 2022-05-19 07:42 262阅读 0赞

# 不一样的单例模式 #

提起单例模式，大家基本上都不是很陌生，它的主要作用是保证在Java的整个项目中只有一个对象的存在，而大家在搜单利模式的时候基本上也会搜出各种各样的写法，比如饿汉式，懒汉式，双重校验锁，静态代码块，静态内部类，枚举等等的写法，基本上算是老生常谈的东西了，但是无论是面试还是日常开发中，单例模式还是挺常用到的，这里介绍一种不一样写法的单例模式，能帮助大家稍微提升一点逼格～

## 1. 目标 ##

作为单例模式，我们有两个基本目标：

1.  全局唯一
2.  线程安全

全局唯一和线程安全就不说了，基本上所有的单例都能满足这两点，那么最好我们的单例可以支持懒加载，同时在保证线程安全的情况下还能够高效一些

## 2. 代码 ##

首先我们来看一下代码：

我们看到在这种单例的写法中，Singleton的实例实在调用getInstance方法的时候才被创建出来的，也就是支持懒加载，而整段代码也并没有使用任何的线程锁，而这个单例得以实现的核心是AtomicReference这个类

### AtomicReference ###

根据API的描述，它是一个可以保证对象更新原子性的一个类，原子意味着多个线程试图改变同一个AtomicReference将不会引发线程安全的问题

AtomicReference有一个非常常用的方法：compareAndSet，这个方法接受两个参数，第一个参数为期望值，第二个参数为你想要设定的值，这个方法的含义是，将AtomicReference中的值更新为第二个参数所传递的值，当当前值为期望值的时候，如果更新成功，则返回true，否则返回false

### 单例说明 ###

那么接下来我们来看看这个单例的执行流程  
首先当第一次调用getInstance的时候，INSTANCE中并没有存储任何的值，所以current为null，那么这时就会创建current对象，并尝试向INSTANCE中更新Singleton的值，只有当INSTANCE中的值为null的时候才可能更新成功，这就保证了在多线程环境中，只能对INSTANCE中的值赋值一次，就保证了线程安全

## 3. 破坏单例 ##

我们在写单例的时候，总是不期望在工程中有多个实例的出现，于是我们将构造方法私有化，并且提供了一个我们可以掌控的入口来创建出一个对象，虽然如此，我们写的单例模式还是有被破坏的可能，所谓破坏单例，就是通过某种手段在整个工程中创建出多个实例，总体来说，破会单例的方式有两种：

1.  通过反射
2.  通过通过序列化

### 3.1 通过反射来破坏单例 ###

我们知道，通过Java的反射技术，我们的代码几乎处于一种“为所欲为”的状态，虽然我们在自己的单例类中将构造方法私有化了，但是可以通过反射轻松的创建出对象，为了让效果更加的明显，首先在单例类中增加一个成员变量：

import java.util.concurrent.atomic.AtomicReference;
    
    /**
     * If there are no bugs, it was created by Chen FengYao on 18-7-16;
     * Otherwise, I don't know who created it either
     */
    public class Singleton {
        
        private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<>();
        
        // 增加的成员变量
        private String name;
    
        public static Singleton getInstance() {
        
            for (; ; ) {
        
                Singleton current = INSTANCE.get();
                if (current != null) {
        
                    return current;
                }
                current = new Singleton();
                if (INSTANCE.compareAndSet(null, current)) {
        
                    return current;
                }
            }
        }
    
        private Singleton() {
        
        }
    
        // setter/getter 方法
        public String getName() {
        
            return name;
        }
    
        public Singleton setName(String name) {
        
            this.name = name;
            return this;
        }
    }

然后我们通过getInstance方法获得一个实例对象,在通过反射来获取一个实例对象:

import java.lang.reflect.Constructor;
    
    /**
     * If there are no bugs, it was created by Chen FengYao on 18-7-15;
     * Otherwise, I don't know who created it either
     */
    public class Main {
        
        public static void main(String[] args) throws Exception {
        
            Singleton singleton = Singleton.getInstance();
            singleton.setName("Tom");
            
            Class<Singleton> singletonClazz = Singleton.class;
            Constructor<Singleton> declaredConstructor = singletonClazz.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            Singleton singleton1 = declaredConstructor.newInstance();
            singleton1.setName("Jerry");
    
            System.out.println(singleton.getName());
            System.out.println(singleton1.getName());
    
        }
    }

运行结果:

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

从运行结果我们可以看出singleton和singleton1是两个对象,就是通过反射我们调用了私有化的构造方法,如果需要抵御这种攻击,可以修改构造器,通过获取方法调用栈信息来判断究竟是我们自己的getInstance方法调用的还是通过反射调用的,如果是通过反射调用的,那么我们就抛出一个运行时异常,在Java中我们可以通过Throwable类来获取方法调用堆栈信息,首先看看效果,在Singleton的构造方法中添加代码:

private Singleton() {
        
        Throwable ex = new Throwable();
        StackTraceElement[] stackElements = ex.getStackTrace();
        if (stackElements != null) {
        
            for (int i = 0; i < stackElements.length; i++) {
        
                System.out.println(stackElements[i].getClassName());
                System.out.println(stackElements[i].getFileName());
                System.out.println(stackElements[i].getLineNumber());
                System.out.println(stackElements[i].getMethodName());
                System.out.println("-----------------------------------");
            }
        }
    }

然后首先看一下通过正常的getInstance来获取对象时的日志:  
![在这里插入图片描述][177fd3be9ff98cbbb6c12d6bb97d1b36.png_pic_center]

可以看到,在第二次循环中,发现类名为Singleton这个类,在看看通过反射调用的方法栈:  
![在这里插入图片描述][47d4e42bd1edae8080441bbd1a48bdff.png_pic_center]

那现在一目了然了,可以看到如果是通过反射调用的,在方法的调用栈中是不会出现getInstance这个方法,或者Singleton这个类的其他信息的,那么我们可以通过去查询方法调用栈来去判断是否有人想要通过反射来破坏我们的单例,如果有,我们就抛出一个运行时异常,改造后的代码如下:

import java.util.concurrent.atomic.AtomicReference;
    
    /**
     * If there are no bugs, it was created by Chen FengYao on 18-7-16;
     * Otherwise, I don't know who created it either
     */
    public class Singleton {
        
        private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<>();
    
        // 增加的成员变量
        private String name;
    
        public static Singleton getInstance() {
        
            for (; ; ) {
        
                Singleton current = INSTANCE.get();
                if (current != null) {
        
                    return current;
                }
                current = new Singleton();
                if (INSTANCE.compareAndSet(null, current)) {
        
                    return current;
                }
            }
        }
    
        private Singleton() {
        
            IllegalStateException illegalStateException = new IllegalStateException("不能调用构造方法,请使用getInstance()来获取实例");
    
            StackTraceElement[] stackElements = illegalStateException.getStackTrace();
    
            if (stackElements != null && !stackElements[1].getClassName().equals(getClass().getName())) {
        
                throw illegalStateException;
            }
        }
    
        // setter/getter 方法
        public String getName() {
        
            return name;
        }
    
        public Singleton setName(String name) {
        
            this.name = name;
            return this;
        }
    }

主要是改造了它的构造方法,在这里选择的是判断调用栈的类名,即调用构造方法的类一定是本类,否则就是通过非法途径调用的,之所以选择类名,因为类名也是可以动态获取的,这样代码一旦写完,后期无论是想改Singleton这个类名,还是想改getInstance这个方法名都是没有问题的,不需要再改构造方法里面的代码了,运行一下看看效果:

public class Main {
        
        public static void main(String[] args) throws Exception {
        
            Singleton singleton = Singleton.getInstance();
            singleton.setName("Tom");
            System.out.println(singleton.getName());
            
            System.out.println("+++++++++++++++");
            Class<Singleton> singletonClazz = Singleton.class;
            Constructor<Singleton> declaredConstructor = singletonClazz.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            Singleton singleton1 = declaredConstructor.newInstance();
            singleton1.setName("Jerry");
    
        }
    }

运行结果:  
![在这里插入图片描述][0321cf9ddfaa653399c2ceb5d5404689.png_pic_center]

可以看到使用getInstance方法调用就不会有问题,而使用反射去调用构造方法就会抛出异常,让程序崩溃

### 3.2 通过序列化来破坏单例 ###

如果一个单例类需要被序列化,那在反序列化的过程中是很有可能破坏单例的设计初衷的,因为反序列化是有可能绕过构造方法的,首先让Singleton 实现Serializable接口,然后编写测试代码:

public class Main {
        
        public static void main(String[] args) throws Exception {
        
            Singleton singleton = Singleton.getInstance();
            singleton.setName("Tom");
    
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton"));
            oos.writeObject(singleton);
            oos.close();
    
            singleton.setName("Tom0");
    
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton"));
            Singleton singleton1 = (Singleton) ois.readObject();
            ois.close();
    
            singleton1.setName("Tom1");
    
            System.out.println(singleton.getName());
            System.out.println(singleton1.getName());
    
        }
    }

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

可以看到反序列化回来的并不再是原来的单例对象了,如果想要让反序列话回来的还是单例对象,需要在单例类中添加readResolve方法,来自己实现反序列化的规则:

public class Singleton implements Serializable {
        
        private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<>();
    
        // 增加的成员变量
        private String name;
    
        public static Singleton getInstance() {
        
            for (; ; ) {
        
                Singleton current = INSTANCE.get();
                if (current != null) {
        
                    return current;
                }
                current = new Singleton();
                if (INSTANCE.compareAndSet(null, current)) {
        
                    return current;
                }
            }
        }
    
        private Singleton() {
        
            IllegalStateException illegalStateException = new IllegalStateException("不能调用构造方法,请使用getInstance()来获取实例");
    
            StackTraceElement[] stackElements = illegalStateException.getStackTrace();
    
            if (stackElements != null && !stackElements[1].getClassName().equals(getClass().getName())) {
        
                throw illegalStateException;
            }
        }
    
        // 用于反序列化
        private Object readResolve(){
        
            return getInstance();
        }
    
        // setter/getter 方法
        public String getName() {
        
            return name;
        }
    
        public Singleton setName(String name) {
        
            this.name = name;
            return this;
        }
    }

再次运行:

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

他们就是同一个对象了

[e5a8f9248dd0dfa641ae845768032d5b.png_pic_center]: /images/20220519/75af6de73f94489ca6ecdb00a09babf0.png
[177fd3be9ff98cbbb6c12d6bb97d1b36.png_pic_center]: /images/20220519/3927a1ddbc3d469a94c461c59831169a.png
[47d4e42bd1edae8080441bbd1a48bdff.png_pic_center]: /images/20220519/468ce57d710d4ec89c931c2f85b22d2e.png
[0321cf9ddfaa653399c2ceb5d5404689.png_pic_center]: /images/20220519/988b9edb8da64d64ae7652a5ced4fe67.png
[b0c8300ab1aa4576276417856f2cd6c5.png_pic_center]: /images/20220519/6de13f6c9a91484a9f39a45ee13ed5e0.png
[64bbfc6f0cd486fad956f729c87e1b1f.png_pic_center]: /images/20220519/daecf8e723f34461bbc2d475ea94e830.png