“读过书，……我便考你一考。茴香豆的茴字，怎样写的？”——鲁迅《孔乙己》

0x00 大纲

0x01 前言

最近在重温设计模式（in Java）的相关知识，然后在单例模式的实现上面进行了一些较深入的探究，有了一些以前不曾注意到的发现，遂将其整理成文，以作后用。

单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”

其应用场景可以说是十分广泛，尤其是在涉及到资源管理方面的代码，像应用配置（实例）、部分工具类或工厂类、JDK里的Runtime等，都有出现单例模式的身影。

0x02 单例的正确性

探讨单例模式有多少种实现方式的意义不是很大，因为单例模式的实现方式比茴字的写法还多，但是正确的实现却不多，我们不妨将重点放在如何保证单例的正确性上，从而寻求最佳实践方案。

单例模式的关键在于如何保证“一个类仅有一个实例”。首先思考一下创建实例的方式有哪些？在Java语言里面，有这几种方式：new关键字、clone方法克隆、反序列化、反射。

new关键字

public class Main {
    public static void main(String[] args) {
        Singleton instance = new Singleton();
    }
}

如果要保证一个类是单例，则必须阻止用户通过new关键字来随意创建对象，最简单粗暴的方法就是将构造方法私有化，然后提供一个静态方法来进行实例的外部访问：

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() { }

    public static Singleton getInstance() {
        return instance;
    }
}

此时就不能在类的外部通过new来创建对象了。

clone方法克隆

clone方法是原型模式中创建复杂对象的方法，在Java中，clone方法是Object基类的方法，因此所有的类都会继承该方法，但只有实现了Cloneable接口的类才能正常调用clone方法克隆对象实例，否则会抛出类型为CloneNotSupportedException的异常，单例的类要防止用户通过clone方法克隆就不能实现Cloneable接口。

反序列化

在Java里面，实现了Serializable接口的类可以通过ObjectOutputStream将其实例序列化，然后再通过ObjectInputStream进行反序列化，而在默认情况下，反序列之后得到的是一个新的实例，这就违背了单例的法则了。幸好JDK的开发人员也想到了这点，再Serializable接口的文档中有这样一段描述：

Classes that need to designate a replacement when an instance of it is read from the stream should implement this special method with the exact signature.

ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

意思就是在反序列化时可以通过在类里面定义readResolve方法来指定反序列化时返回的对象，例如：

public class Singleton implements java.io.Serializable {
    private static final long serialVersionUID = 1L;
    private static Singleton instance = new Singleton();

    private Singleton() {
        if(instance != null) {
            throw new RuntimeException("Not Allowed.");
        }
    }

    public static Singleton getInstance() {
        return instance;
    }

    private Object readResolve() throws java.io.ObjectStreamException {
        return getInstance();
    }
}

反射

聪明的你也许注意到了，上面的readResolve方法是private的。那么它是怎么被调用的呢？答案就是通过反射，想了解更详细的调用过程可以去看看ObjectInputStream类源码中的readOrdinaryObject方法。

通过反射可以无视private修饰符的限制调用类里面的各种方法，也就是说用户可以利用反射来调用我们的私有构造方法，像这样：

public class Main {
    public static void main(String[] args) throws Exception {
        // 这句代码无法执行，因为我们的构造方法是private的
        // Singleton singleton = new Singleton();
        // 通过反射来创建实例
        java.lang.reflect.Constructor<Singleton> constructor;
        constructor = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton singleton = constructor.newInstance();
        // 两个实例不一样，单例完蛋
        if(singleton != Singleton.getInstance()) {
            System.out.println("哦嚯，完蛋");
        }
    }
}

解决方法是在构造方法里面判断类的实例是否已经被创建过，如果已经创建过的，抛出异常从而阻止反射调用。把单例类的代码修改如下：

public class Singleton implements java.io.Serializable {
    private static final long serialVersionUID = 1L;
    private static Singleton instance = new Singleton();
    private Singleton() {
        if(instance != null) {
            throw new RuntimeException("Not Allowed.");
        }
    }

    public static Singleton getInstance() {
        return instance;
    }

    /**
     * 显式指定反序列化时返回的单例对象
     * @return
     * @throws java.io.ObjectStreamException
     */
    private Object readResolve() throws java.io.ObjectStreamException {
        return getInstance();
    }
}

再次通过反射进行对象创建时，就会抛出类型为RuntimeException的异常，从而阻止新实例的创建。

0x03 最佳实践方案

可以看到，我们为了实现单例模式，加入了一大堆胶水代码，用于保证其正确性，这一点都不简洁。那么有没有更简单更有效的方式呢？有，而且已经有人帮我们验证过了。

Joshua Bloch在《Effective Java》一书中写道：

使用枚举实现单例的方法虽然还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。

我们直接上代码看看：

public enum EnumSingleton {
    INSTANCE;
    public void doSomething() {
        System.out.println("do something.");
    }
}

就是这么简单，再看看调用它的代码：

public class Main {
    public static void main(String[] args) {
        EnumSingleton.INSTANCE.doSomething();
    }
}

使用枚举实现单例模式，不仅代码简洁，而且可以轻松阻止用户通过new关键字、clone方法克隆、反序列化、反射等方式创建重复实例，还保证线程安全，这一切由JVM替你操办，不需要添加额外代码。

0x04 验证测试

枚举实现单例模式能不能保证上面的提到的各种属性呢？我们用代码逐一验证一下：

public class Main {
    public static void main(String[] args) throws Exception {
        // TEST-1: 验证是否单一实例
        EnumSingleton s1 = EnumSingleton.INSTANCE;
        EnumSingleton s2 = EnumSingleton.INSTANCE;
        if (s1.hashCode() != s2.hashCode()) {
            System.out.println("哦嚯，完蛋");
        } else {
            System.out.println("TEST-1 PASSED.");
        }
        // TEST-2: 验证反射创建
        java.lang.reflect.Constructor<EnumSingleton> constructor;
        // 注意这里用的是枚举的父构造器，因为我们没有定义构造方法
        constructor = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
        constructor.setAccessible(true);
        boolean passed = false;
        try {
            EnumSingleton s3 = constructor.newInstance("NEW_INSTANCE", 2);
        } catch (Exception ex) {
            // 报错说明反射不能创建
            passed = true;
        }
        if (!passed) {
            System.out.println("哦嚯，完蛋");
        } else {
            System.out.println("TEST-2 PASSED.");
        }
        // TEST-3: 验证反序列化
        EnumSingleton s4 = EnumSingleton.INSTANCE;
        EnumSingleton s5;
        try (java.io.ObjectOutputStream oos = new java.io.ObjectOutputStream(new java.io.FileOutputStream("EnumObject"))) {
            oos.writeObject(s4);
        }
        try (java.io.ObjectInputStream ois = new java.io.ObjectInputStream(new java.io.FileInputStream("EnumObject"))) {
            s5 = (EnumSingleton) ois.readObject();
        }
        if (s4.hashCode() != s5.hashCode()) {
            System.out.println("哦嚯，完蛋");
        } else {
            System.out.println("TEST-3 PASSED.");
        }
        // TEST-4: 多线程测试
        java.util.concurrent.CountDownLatch begin = new java.util.concurrent.CountDownLatch(10);
        java.util.concurrent.CountDownLatch end = new java.util.concurrent.CountDownLatch(10);
        java.util.Set<EnumSingleton> set = new java.util.HashSet<>(1024);
        java.util.stream.IntStream.range(0, 20).forEach(
                i -> {
                    new Thread(() -> {
                        try {
                            begin.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        set.add(EnumSingleton.INSTANCE);
                        System.out.println(System.currentTimeMillis() + ":" + Thread.currentThread().getName() + "->" + EnumSingleton.INSTANCE.hashCode());
                        end.countDown();
                    }).start();
                    begin.countDown();
                }
        );
        end.await();
        if(set.size() != 1) {
            System.out.println("哦嚯，完蛋");
        } else {
            System.out.println("TEST-4 PASSED.");
        }
    }
}

测试结果：

TEST-1 PASSED.
TEST-2 PASSED.
TEST-3 PASSED.
...
TEST-4 PASSED.

0x05 真的是最佳实践吗

在 Java Language Specification 枚举类型这一章节中，具体阐述了若干点对于枚举类型的强制和隐性约束：

An enum declaration specifies a new enum type, a special kind of class type.

It is a compile-time error if an enum declaration has the modifier abstract or final.

An enum declaration is implicitly final unless it contains at least one enum constant that has a class body (§8.9.1).

A nested enum type is implicitly static. It is permitted for the declaration of a nested enum type to redundantly specify the static modifier.

This implies that it is impossible to declare an enum type in the body of an inner class (§8.1.3), because an inner class cannot have static members except for constant variables.

It is a compile-time error if the same keyword appears more than once as a modifier for an enum declaration.

The direct superclass of an enum type E is Enum (§8.1.4).

An enum type has no instances other than those defined by its enum constants. It is a compile-time error to attempt to explicitly instantiate an enum type (§15.9.1).

其中最为突出和有影响是以下两点：

不能显式继承

和常规类一样，枚举可以实现接口，并提供公共实现或每个枚举值的单独实现，但不能继承，因为所有的枚举默认隐式继承了Enum<E>类型，不能继承也就意味着丧失了一部分的抽象能力（不能定义abstract方法），虽然可以通过组合的方式变通实现，但这无疑牺牲了扩展性和灵活性。

无法延迟加载

因为枚举实例化的特殊性，所有的构造器属性都必须在枚举创建时指定，无法在运行时通过代码动态传递和构造。

0x06 小结

非枚举的单例实现除开少数极端场景，在大多数时候下也都够用了，且保留了OOP的灵活特性，方便日后业务扩展，基于枚举的单例实现有序列化和线程安全的保证，而且只要几行代码就能实现，不失为一种有效的方案，但并不无敌。具体的实现方案还是要根据业务背景和实际情况来进行选择，毕竟，软件工程没有银弹。