为何我强烈推荐你用枚举来实现单例模式

单例模式简介

单例模式是 Java 中最简单，也是最基础，最经常使用的设计模式之一。在运行期间，保证某个类只建立一个实例，保证一个类仅有一个实例，并提供一个访问它的全局访问点。下面就来说讲Java中的N种实现单例模式的写法。

饿汉式

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }

}

复制代码

这是实现一个安全的单例模式的最简单粗暴的写法，这种实现方式咱们称之为饿汉式。之因此称之为饿汉式，是由于肚子很饿了，想立刻吃到东西，不想等待生产时间。这种写法，在类被加载的时候就把Singleton实例给建立出来了。

饿汉式的缺点就是，可能在还不须要此实例的时候就已经把实例建立出来了，没起到lazy loading的效果。优势就是实现简单，并且安全可靠。

懒汉式

public class Singleton {
    
    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    
}
复制代码

相比饿汉式，懒汉式显得没那么“饿”，在真正须要的时候再去建立实例。在getInstance方法中，先判断实例是否为空再决定是否去建立实例，看起来彷佛很完美，可是存在线程安全问题。在并发获取实例的时候，可能会存在构建了多个实例的状况。因此，须要对此代码进行下改进。

public class SingletonSafe {

    private static volatile SingletonSafe singleton;

    private SingletonSafe() {
    }

    public static SingletonSafe getSingleton() {
        if (singleton == null) {
            synchronized (SingletonSafe.class) {
                if (singleton == null) {
                    singleton = new SingletonSafe();
                }
            }
        }
        return singleton;
    }
}
复制代码

这里采用了双重校验的方式，对懒汉式单例模式作了线程安全处理。经过加锁，能够保证同时只有一个线程走到第二个判空代码中去，这样保证了只建立 一个实例。这里还用到了volatile关键字来修饰singleton，其最关键的做用是防止指令重排。

静态内部类

public class Singleton {

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

    private Singleton() {
        
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}
复制代码

经过静态内部类的方式实现单例模式是线程安全的，同时静态内部类不会在Singleton类加载时就加载，而是在调用getInstance()方法时才进行加载，达到了懒加载的效果。

彷佛静态内部类看起来已是最完美的方法了，其实不是，可能还存在反射攻击或者反序列化攻击。且看以下代码：

public static void main(String[] args) throws Exception {
    Singleton singleton = Singleton.getInstance();
    Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    Singleton newSingleton = constructor.newInstance();
    System.out.println(singleton == newSingleton);
}
复制代码

运行结果：

经过结果看，这两个实例不是同一个，这就违背了单例模式的原则了。

除了反射攻击以外，还可能存在反序列化攻击的状况。以下：

引入依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.8.1</version>
</dependency>
复制代码

这个依赖提供了序列化和反序列化工具类。

Singleton类实现java.io.Serializable接口。

以下：

public class Singleton implements Serializable {

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

    private Singleton() {

    }

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

    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        byte[] serialize = SerializationUtils.serialize(instance);
        Singleton newInstance = SerializationUtils.deserialize(serialize);
        System.out.println(instance == newInstance);
    }

}
复制代码

运行结果：

经过枚举实现单例模式

在effective java（这本书真的很棒）中说道，最佳的单例实现模式就是枚举模式。利用枚举的特性，让JVM来帮咱们保证线程安全和单一实例的问题。除此以外，写法还特别简单。

public enum Singleton {

    INSTANCE;

    public void doSomething() {
        System.out.println("doSomething");
    }

}
复制代码

调用方法：

public class Main {

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

}

复制代码

直接经过Singleton.INSTANCE.doSomething()的方式调用便可。方便、简洁又安全。

总结

以上列举了多种单例模式的写法，分析了其利弊之处。同时还介绍了目前最佳的单例写法——枚举模式，相信在将来，枚举模式的单例写法也会愈来愈流行。