Java中单例模式的安全性分析

文章首发于我的博客，欢迎访问：https://blog.itzhouq.cn/singleton

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

本文主要介绍以下内容：

两种单例模式
单例模式的线程安全验证
双重检测锁模式的单例模式
反射破坏单例模式
反编译字节码的两种方式

1、饿汉式单例模式

最简单的饿汉式单例模式代码：

package cn.itzhouq.single;

/**
 * 饿汉式单例:
 *      1. 私有化空参构造器
 *      2. 私有状态直接创建对象
 *      3.提供公有的获得对象的方法
 */
public class Hungry {

    // 可能会浪费空间
    private byte[] data1 = new byte[1024 * 2014];
    private byte[] data2 = new byte[1024 * 2014];
    private byte[] data3 = new byte[1024 * 2014];
    private byte[] data4 = new byte[1024 * 2014];

    private Hungry () {

    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance() {
        return HUNGRY;
    }
}

为了防止资源浪费，我们需要在使用对象的时候再去创建单例对象，所以就有了懒汉式。

2、懒汉式单例模式

最简单的懒汉式单例：

package cn.itzhouq.single;

/**
 * 懒汉式单例
 */
public class LazyMan {

    private LazyMan () {

    }

    private static LazyMan lazyMan;

    public static LazyMan getInstance () {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

上述代码在单线程是 OK 的，但是在多线程下是不安全的。现在在多线程下做个测试：

package cn.itzhouq.single;

/**
 * 懒汉式单例
 */
public class LazyMan {

    private LazyMan () {
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private static LazyMan lazyMan;

    public static LazyMan getInstance () {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    // 多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}

结果是创建的对象大概率不是单例：

Thread-0ok
Thread-3ok
Thread-2ok
Thread-1ok

所以我们需要加锁解决这个问题。

3、双重检测锁模式的单例模式（DCL 懒汉式）

package cn.itzhouq.single;

/**
 * 懒汉式单例
 */
public class LazyMan {

    private LazyMan () {}

    private static LazyMan lazyMan;

    // 双重检测锁模式的懒汉式单例 DCL 懒汉式
    public static LazyMan getInstance () {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

这种懒汉式在极端情况下还是有问题的，问题出现在lazyMan = new LazyMan();。

因为这一步不是原子性操作，会经历以下三步：

分配内存空间
执行构造方法，初始化对象
把这个对象指向这个空间

在底层可能会出现指令重排，比如我们预期这三步的顺序是 123，但是真实可能出现 132。也就是线程 A 首先执行1，再执行3，这个在 CPU 中是可以做到的。

A线程下首先分配了内存空间，然后这个对象指向某个空间，但是第2步没有执行，没有初始化对象。

这个时候如果有一个B线程开始执行，执行到16行，判断 lazyMan 是否为 null。由于这个对象已经指向了特定空间，所以不为 null ，直接返回 lazyMan ，这个时候对象还没有执行构造方法，进行初始化。

所以为了防止指令重排，必须加上 volatile。关于volatile，以后再更新相关内容，读者也可以自行百度，学习相关知识。

package cn.itzhouq.single;

/**
 * 懒汉式单例
 */
public class LazyMan {

    private LazyMan () {
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    // 添加 volatile 保证原子性
    private volatile static LazyMan lazyMan;

    // 双重检测锁模式的懒汉式单例 DCL 懒汉式
    public static LazyMan getInstance () {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan(); // 不是原子性操作
                }
            }
        }
        return lazyMan;
    }
}

面试题的时候至少要说出以上几点。

4、静态内部类实现单例模式（了解）

还有一种方式可以实现单例模式 --- 内部类。

package cn.itzhouq.single;

/**
 * 静态内部类实现单例模式
 */
public class Holder {
    private Holder() {

    }

    public static Holder getInstance() {
        return InnerClass.HOLDER;
    }

    public static class InnerClass {
        public static final Holder HOLDER = new Holder();
    }
}

这种方式了解一下。

5、使用反射破坏单例

上面的单例模式日常开发中够用，但要知道DCL 懒汉式代码也不是绝对安全的。使用反射就能破坏其安全性。

// 反射
public static void main(String[] args) throws Exception {
    LazyMan instance = lazyMan.getInstance();
    // 使用反射获取空参构造器
    Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
    // 取消权限检查
    declaredConstructor.setAccessible(true);
    LazyMan instance2 = declaredConstructor.newInstance();
    System.out.println(instance == instance2); // false
}

获取到的两个对象不相等，说明不是单例模式。

试图通过标志位解决这个问题：

package cn.itzhouq.single;
import java.lang.reflect.Constructor;
/**
 * 懒汉式单例
 */
public class LazyMan {

    private static boolean flag = false;

    private LazyMan () {
        synchronized (LazyMan.class) {
            if (!flag) {
                flag = true;
            } else {
                throw new RuntimeException("不要试图通过反射破坏单例。");
            }
        }
    }

    private volatile static LazyMan lazyMan;

    // 双重检测锁模式的懒汉式单例 DCL 懒汉式
    public static LazyMan getInstance () {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan(); // 不是原子性操作
                }
            }
        }
        return lazyMan;
    }
}

// 反射
public static void main(String[] args) throws Exception {
    // LazyMan instance = lazyMan.getInstance();
    // 使用反射获取空参构造器
    Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
    // 取消权限检查
    declaredConstructor.setAccessible(true);
    LazyMan instance1 = declaredConstructor.newInstance();
    LazyMan instance2 = declaredConstructor.newInstance();
    System.out.println(instance1 == instance2); // 抛出异常
}

如果这里的 flag 外界看不到的，这样就可以解决了，但是如果这个私有的属性也被暴露了也还是不安全。

下面的代码通过反射修改属性的值。

package cn.itzhouq.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**
 * 懒汉式单例
 */
public class LazyMan {

    private static boolean flag = false;

    private LazyMan () {
        synchronized (LazyMan.class) {
            if (!flag) {
                flag = true;
            } else {
                throw new RuntimeException("不要试图通过反射破坏单例。");
            }
        }
    }

    private volatile static LazyMan lazyMan;

    // 双重检测锁模式的懒汉式单例 DCL 懒汉式
    public static LazyMan getInstance () {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan(); // 不是原子性操作
                }
            }
        }
        return lazyMan;
    }
}

// 反射
public static void main(String[] args) throws Exception {
    // LazyMan instance = lazyMan.getInstance();

    Field flag = LazyMan.class.getDeclaredField("flag");
    flag.setAccessible(true);

    // 使用反射获取空参构造器
    Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
    // 取消权限检查
    declaredConstructor.setAccessible(true);
    LazyMan instance1 = declaredConstructor.newInstance();

    flag.set(instance1, false);
    LazyMan instance2 = declaredConstructor.newInstance();
    System.out.println(instance1 == instance2); // false
}

6、枚举实现单例模式

查看newInstance()方法的源码，里面注释到反射不能破坏枚举类型。Cannot reflectively create enum objects。

@CallerSensitive
public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, null, modifiers);
        }
    }
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}

所以我们可以通过枚举类型实现单例模式。

package cn.itzhouq.single;

/**
 * enum 其实本身也是一个 Class 类
 */
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance() {
        return INSTANCE;
    }
}

class Test {
    public static void main(String[] args) {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        EnumSingle instance2 = EnumSingle.INSTANCE;

        System.out.println(instance1 == instance2); // true
    }
}

没有问题，两次获得的同一个对象。这种通过枚举的方式还没有被广泛采用，但这是实现单例模式的最佳方式。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。

下面尝试使用反射破坏枚举类型。

7、反射破坏枚举

查看枚举类实现的源码，发现一个空参构造器，尝试使用反射获得空参构造器，然后创建单例的对象。

枚举类的实现

class Test {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1 == instance2);
    }
}

Exception in thread "main" java.lang.NoSuchMethodException: cn.itzhouq.single.EnumSingle.<init>()
	at java.lang.Class.getConstructor0(Class.java:3082)
	at java.lang.Class.getDeclaredConstructor(Class.java:2178)
	at cn.itzhouq.single.Test.main(EnumSingle.java:21)

运行抛出了异常。但是异常信息显示没有这样的构造方法，这根反射不能破坏枚举类型的异常信息不一致。存在疑点，下面尝试使用反编译的方式查看源码分析。

8、反编译枚举类

反编译枚举类，分析代码实现。

使用 JDK 自带的反编译工具编译代码

发现代码中还是显示空参构造器。

反编译

这里反编译的命令是：

javap -p EnumSingle.class

使用 jad 工具反编译的工具：

jad -s java EnumSingle.class
Parsing EnumSingle.class... Generating EnumSingle.java

查看反编译的代码：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   EnumSingle.java

package cn.itzhouq.single;


public final class EnumSingle extends Enum
{

    public static EnumSingle[] values()
    {
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(cn/itzhouq/single/EnumSingle, name);
    }

    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public EnumSingle getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
            INSTANCE
        });
    }
}

可以看到 22 到 25 行，该枚举类并不是使用的无参构造器。而是使用的两个参数，根据这两个参数修改获取构造器的方法。

class Test {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1 == instance2); // true
    }
}

再看这次的异常信息：

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at cn.itzhouq.single.Test.main(EnumSingle.java:23)

是符合上面的源码提示信息的。至此，关于的单例模式的安全性分析到此结束了。
参考文章

posted @ 2020-04-20 21:09 itzhouq 阅读(428) 评论(0) 编辑收藏举报

刷新页面返回顶部

itzhouq的博客