单例模式的几种写法与攻击方法

单例模式的几种写法与优缺点分析

饿汉式

/**
 * 饿汉式
 * 这种方式是最简单也最好理解的
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就完成实例化
 * Class.forName("")
 * （话说你不用的，你装载它干啥）
 * ---- 解决方法：懒加载
 */
public class StaticFinal {
    /**
     * JVM保证每个Class只会漏到内存一次
     * static修饰符 让Class漏到内存之后马上进行初始化这个变量
     * 当然不同得
     */
    private static final StaticFinal INSTANCE = new StaticFinal();

//    还有一种写法
//    private static final INSTANCE INSTANCE;
//    static {
//        INSTANCE = new StaticFinal();
//    }

    /**
     * 让其他方法无法通过 new StaticFinal 获取实例
     */
    private StaticFinal() {}

    public static StaticFinal getInstance() {
        return INSTANCE;
    } 
}

懒汉式

/**
 * 懒加载（懒汉模式）
 * 目的：按需加载
 * 线程不安全
 * 解决方法：双重校验锁（下一个就是）
 */
public class LazyLoading {
    private static LazyLoading INSTANCE;
    private LazyLoading() {}
    
    public static LazyLoading getInstance() {
        if (INSTANCE == null) {
            /**
             * 但是如果当第一个线程在创建对象但是还没有创建成功，第二个线程进来，
             * 就会创建两个对象，这就是线程不安全的地方
             */
            try {
                //模拟初始化过程浪费的时间
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /**
             * thread_2:我就在thread_1上面，
             * INSTANCE 为空时我进来的，
             * 等thread_1创建完了我也会创建创建一次，
             * 系统中就存在两个INSTANCE对象了
             *
             * thread_1：我在这，我现在要创建对象
             */
            INSTANCE = new LazyLoading();
        }
        return INSTANCE;
    }

    /**
     * 检查对象的hashCode 是否一致来判断是否是相同的对象
     */
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.err.println(LazyLoading.getInstance().hashCode());
            }).start();
        }
    }
}

懒汉式（双重校验锁）

import java.io.Serializable;
public class DoubleCheck implements Serializable {
    /** volatile 可以禁止指令重排 */
    private static /* volatile */ DoubleCheck INSTANCE;
    private DoubleCheck() {}
    /**
     * 在需要加锁的时候加锁
     */
    /**
    * synchronized 也可以直接加在方法中，但是如果方法中有其他业务逻辑会影响整体执行速度
    */
    public static /* synchronized */ DoubleCheck getInstance() {
//        当 INSTANCE == null 时继续执行，否则直接返回
        if (INSTANCE == null) {
//            当检测到 INSTANCE 为空，直接上锁，不允许其他线程访问
            synchronized (DoubleCheck.class) {
//                第二次检查INSTANCE是否有值，如果有值则直接返回，否则继续执行
//                因为加上了synchronized 锁，这时其他线程无法进入，这里就是双重检查
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new DoubleCheck();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.err.println(DoubleCheck.getInstance().hashCode());
            }).start();
        }
    }
}

但是这里有一个问题需要说明，程序看起来是没有问题的，但是在高并发的情况下会出现空指针的情况，

这是因为程序在创建对象的时候分为三步：

• 分配内存空间
• 创建对象
• 为对象指向内存空间

这只是我们的预期，这里需要谈到CUP执行指令的一个问题，CUP只是从缓存区里取出指令然后执行，但是CUP还有个功能是可以优化指令的执行的，所以为了某些优化方案，CUP会将指令重排，也就是CUP的乱序执行，这部分可以参考我的另一篇博客：https://blog.youkuaiyun.com/qq_36623327/article/details/107622833

也就是说CUP可能不会按照我们的预期一步一步按顺序执行命令，其执行步骤可能是这样的

• 分配内存空间
• 为对象指向内存空间
• 创建对象

这当然也可以正常的创建出一个对象，在线程数没那么多的时候也没什么问题，问题的点在于，当处于高并发，程序执行到 为对象分配内存空间 这一步，第二个线程（thread_2）进来了，因为已经分配了内存空间，所以当前对象不为空，thread_2 拿到的结果就是当前实例不为空，直接使用还没有初始化好的对象，就会出现空指针异常，解决这个问题就是在对象前加入 volatile 关键字，因为 volatile 有一个功能叫做 禁止指令重排 ，这样就解决了其他线程乘虚而入的途径

静态内部类

public class StaticClass {
    private StaticClass() {}
    /**
     * JVM 加载外部类不会加载内部类,不会出现没用到就加载的情况
     * 需要使用的时候调用内部类,完成初始化,实现按需加载,
     * 线程安全,JVM 保证,加载Class只加载一次
     * 这种方式比较简单也没有明显的缺点，如果非要说缺点就是可以被使用反射的方式攻击（下文有说明）
     */
    private static class StaticClassHolder {
        private final static StaticClass INSTANCE = new StaticClass();
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.err.println(StaticClass.getInstance().hashCode());
            }).start();
        }
    }
}
	

枚举

/**
 * 解决线程同步,反序列化的问题
 * 因为枚举类没有构造方法,反射需要使用无参构造方法,反序列化得到的又是同一个对象
 */
public enum EnumInstance {
     INSTANCE;
     public EnumInstance doSomeThing(){
        return this ;
     }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.err.println(EnumInstance.INSTANCE.doSomeThing().hashCode());
            }).start();
        }
    }
}

CAS 方式

import java.util.concurrent.atomic.AtomicReference;
public class CAS {
    /**
     * CAS ： compareAndSet
     * 基本原理
     * compareAndSet(当前值：oldValue,期望的值：expect,要设置的新值：newValue)
     * 如果传入的当前值和真实的当前值匹配，则直接进行操作
     * 当如的当前值和真实的当前值不匹配，则将传入的oldValue 修改为真正的当前值并再次调用本方法
     * 因为CAS使用的是CPU原语，不会出现某个时间点因为初始化等问题导致值不可用的情况
     */
    private static final AtomicReference<CAS> INSTANCE = new AtomicReference<CAS>();
    private CAS() {}
    public static CAS getInstance() {
        for (; ; ) {
            CAS instance = INSTANCE.get();
            if (instance != null) {
                return instance;
            }
            instance = new CAS();
            if (INSTANCE.compareAndSet(null, instance)) {
                return instance;
            }
        }
    }
}

Lock 可重入锁

import java.util.concurrent.locks.ReentrantLock;
/**
*  和双重校验锁差不多，这种更加灵活
*/
public class Lock {
    private static Lock instance = null;
    private static ReentrantLock lock = new ReentrantLock();
    private Lock() {}
    public static Lock getInstance() {
        if(instance == null) {
            lock.lock(); // 显式调用，手动加锁
            if(instance == null) {
                instance = new Lock();
            }
            lock.unlock(); // 显式调用，手动解锁
        }
        return instance;
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->{
                System.err.println(Lock.getInstance().hashCode());
            }).start();
        }
    }
}

单例模式的攻击

import java.io.*;
import java.lang.reflect.Constructor;
/**
 * 单例模式的创建与攻击
 */
public class SingletonAttack {
    public static void main(String[] args) throws Exception {
        reflectionAttack();
//        serializationAttack();
    }
    /**
     * 单例模式反射攻击
     * @throws Exception
     */
    public static void reflectionAttack() throws Exception {
        Constructor<DoubleCheck> constructor = DoubleCheck.class.getDeclaredConstructor();
        constructor.setAccessible(true); // 允许访问私有对象
        System.err.println(constructor.newInstance() == constructor.newInstance());
    }

    /**
     * 单例模式序列化攻击
     * @throws Exception
     */
    /**
     * 为什么会发生这种事？
     * 在ObjectInputStream.readObject()方法执行时，其内部方法readOrdinaryObject()中有这样一句话:
     * *** obj = desc.isInstantiable() ? desc.newInstance() : null; ***
     * 其中desc是类描述符。也就是说，如果一个实现了Serializable/Externalizable接口的类可以在运行时实例化，
     * 那么就调用newInstance()方法，使用其默认构造方法反射创建新的对象实例，自然也就破坏了单例性。
     * 要防御序列化攻击，就得将 instance声明为 transient，
     * private static volatile transient DoubleCheck INSTANCE;
     * transient : 将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会被序列化
     * 并且在单例中加入以下语句：
     * private Object readResolve() {
     * return instance;
     * }
     * 这是因为在上述readOrdinaryObject()方法中，
     * 会通过语句desc.hasReadResolveMethod()检查类中是否存在名为readResolve()的方法，
     * 如果有，就执行desc.invokeReadResolve(obj)调用该方法。
     * readResolve()会用自定义的反序列化逻辑覆盖默认实现，因此强制它返回instance本身，
     * 就可以防止产生新的实例
     *
     * @throws Exception
     */
    public static void serializationAttack() throws Exception {
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("serFile"));
        DoubleCheck s1 = DoubleCheck.getInstance();
        outputStream.writeObject(s1);
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(new File("serFile")));
        DoubleCheck s2 = (DoubleCheck) inputStream.readObject();
        System.out.println(s1 == s2);
    }
}