老司机来教你单例的正确姿势

Java单例模式可能是最简单也是最常用的设计模式，一个完美的单例需要做到哪些事呢？

单例（这不是废话吗）
延迟加载
线程安全
没有性能问题
防止序列化产生新对象
防止反射攻击

可以看到，真正要实现一个完美的单例是很复杂的，那么，让我这个司机带大家看一看正确姿势的单例。

最佳实践单例之枚举

没错，直接就上最佳实践，就是这么任性

这货长这样：

public enum Singleton{
    INSTANCE;
}

如果你不熟悉枚举，可能会说：这货是啥？！

这种方式的好处是：

利用的枚举的特性实现单例
由JVM保证线程安全
序列化和反射攻击已经被枚举解决

调用方式为Singleton.INSTANCE, 出自《Effective Java》第二版第三条: 用私有构造器或枚举类型强化Singleton属性。

下面将会介绍更为常见的单例模式，但是均未处理反射攻击，如果想了解更多可以看这篇文章：如何防止单例模式被JAVA反射攻击

最简单的单例之饿汉式

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    // 私有化构造函数
    private Singleton(){}

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

这种单例的写法最简单，但是缺点是一旦类被加载，单例就会初始化，没有实现懒加载。而且当实现了Serializable接口后，反序列化时单例会被破坏。

实现Serializable接口需要重写readResolve，才能保证其反序列化依旧是单例：

public class Singleton implements Serializable {
    private static final Singleton INSTANCE = new Singleton();
    // 私有化构造函数
    private Singleton(){}

    public static Singleton getInstance(){
        return INSTANCE;
    }
        
    /**
     * 如果实现了Serializable, 必须重写这个方法
     */
    private Object readResolve() throws ObjectStreamException {
        return INSTANCE;
    }
}

OK，反序列化要注意的就是这一点，下面的内容中就不再复述了。

最体现技术的单例之懒汉式

懒汉式即实现延迟加载的单例，为上述饿汉式的优化形式。而因其仍需要进一步优化，往往成为面试考点，让我们一起来看看坑爹的“懒汉式”

懒汉式的最初形式是这样的：

public class Singleton {
    private static Singleton INSTANCE;
    private Singleton (){}
    
    public static Singleton getInstance() {
     if (INSTANCE == null) {
         INSTANCE = new Singleton();
     }
     return INSTANCE;
    }
}

这种写法就轻松实现了单例的懒加载，只有调用了getInstance方法才会初始化。但是这样的写法出现了新的问题--线程不安全。当多个线程调用getInstance方法时，可能会创建多个实例，因此需要对其进行同步。

如何使其线程安全呢？简单，加个synchronized关键字就行了

public static synchronized Singleton getInstance() {
    if (INSTANCE == null) {
        INSTANCE = new Singleton();
    }
    return INSTANCE;
}

可是...这样又出现了性能问题，简单粗暴的同步整个方法，导致同一时间内只有一个线程能够调用getInstance方法。

因为仅仅需要对初始化部分的代码进行同步，所以再次进行优化：

public static Singleton getSingleton() {
    if (INSTANCE == null) {              // 第一次检查
        synchronized (Singleton.class) {
            if (INSTANCE == null) {      // 第二次检查
                INSTANCE = new Singleton();
            }
        }
    }
    return INSTANCE ;
}

执行两次检测很有必要：当多线程调用时，如果多个线程同时执行完了第一次检查，其中一个进入同步代码块创建了实例，后面的线程因第二次检测不会创建新实例。

这段代码看起来很完美，但仍旧存在问题，以下内容引用自黑桃夹克大神的如何正确地写出单例模式

给 instance 分配内存
调用 Singleton 的构造函数来初始化成员变量
将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

public class Singleton {
    private volatile static Singleton INSTANCE; //声明成 volatile
    private Singleton (){}

    public static Singleton getSingleton() {
        if (INSTANCE == null) {                         
            synchronized (Singleton.class) {
                if (INSTANCE == null) {       
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
   
}

至此，这样的懒汉式才是没有问题的懒汉式。

内部类实现单例

public class Singleton { 
    /** 
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系， 
     * 而且只有被调用到才会装载，从而实现了延迟加载 
     */ 
    private static class SingletonHolder{ 
        /** 
         * 静态初始化器，由JVM来保证线程安全 
         */ 
        private static final Singleton instance = new Singleton(); 
    } 
    /** 
     * 私有化构造方法 
     */ 
    private Singleton(){ 
    } 
     
    public static  Singleton getInstance(){ 
        return SingletonHolder.instance; 
    } 
}

使用内部类来维护单例的实例，当Singleton被加载时，其内部类并不会被初始化，故可以确保当 Singleton类被载入JVM时，不会初始化单例类。只有 getInstance() 方法调用时，才会初始化 instance。同时，由于实例的建立是时在类加载时完成，故天生对多线程友好，getInstance() 方法也无需使用同步关键字。

总结

无疑，单例就应使用枚举实现，最佳实践诚不欺我

老司机来教你单例的正确姿势

老司机来教你单例的正确姿势

最佳实践单例之枚举

最简单的单例之饿汉式

最体现技术的单例之懒汉式

内部类实现单例

总结

参考链接