JAVA如何正确写出一个单例模式？看这里就够了

什么是单例模式？

保证一个类只有一个实例，且在类里面提供一个全局可以访问的入口。如图 Singleton 类，提供了一个 getInstance() 入口获取这个实例。

为什么需要单例？

• 节省内存
• 节省计算
• 保证结果的正确（需要一个全局的计数器）
• 方便管理（很多工具类只需要一个实例）

很多类并不需要创建大量的实例。如：初始化时的类，在第一次构造的时候花了大量的时间进行初始化该对象。

public class ExpensiveResource {
    public ExpensiveResource () {
        field1 = // 查询数据库
        field2 = // 对查询的数据进行计算
        field3 = // 加密、压缩等耗时操作
    }
}

适用场景

常见的单例模式写法

• 饿汉式
• 懒汉式
• 双重检查式(又名double-check)
• 静态内部类式
• 枚举式(目前最好的实现方式)

下面就是从简单到最后的枚举式，逐步递增，去看看这个单例是怎么写的。各个方式有什么弊端，才最后产生了枚举式。

饿汉式

写法1：
public class Singleton {
    private static Singleton singlenton = new Singlention();
    
    private Singleton() {}
    
    public Singlenton getInstance() {
        return singlenton;
    }
}

---------------------------------------------------------
写法2：
public class Singleton() {
    private static Singleton singleton;
    
    static {
        singleton = new Singleton();
    }
    
    private Singleton() {}
    
    public Singlenton getInstance() {
        return singlenton;
    }
}

如上所示：

1. static 来修饰实例
2. 构造函数用 private 修饰
3. 实例直接在加载时候 new.

写法最简单，在类装载的时候就实例化了，避免线程同步的问题。
但是 缺点是类加载就完成了实例化 。没有达到懒加载。

很明显，如果永远都用不上这个类的话，那就资源浪费了。所以产生了下面的懒汉式。

懒汉式

线程不安全的写法：

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

很明显在 getInstance() 中增加了判断，在获取的时候才去实例化。这个就是懒加载了。

但是注意了，这种只适合单线程，如果多线程，就会出现实例化多次的情况。场景重现：

线程1：进入了 if 语句，准备进行实例化。此时线程2进来了，线程1被挂起。

线程2：进入 if 语句，创建完实例后，切换回线程1 继续执行。

线程1：继续实例化 Singleton。

这个时候就出现了初始化多次了。很明显多线程下->这是一个错误的写法。

线程安全的写法（改写 getInstance()方法）：

public class Singleton {
    private static Singleton singlenton;
    
    private Singleton() {}
    
    public static synchronized Singlenton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

增加锁，锁住整个方法。
但是缺点是：执行效率十分低。因为每个线程 getInstance() 都要进行同步，多个线程的时候，必须要等待一个一个的来。

所以我们再升级一下写法，再改改 getInstance()：

public static Singlenton getInstance() {
    if (singleton == null) {
        synchronzied (Singleton.class) {
            singleton = new Singleton();    
        }
    }
    return singleton;
}

不过还是有问题的，一样的并发情况下，还是会出现上面线程不安全的问题。

左思右想，还是不行。所以最后为了解决这个问题。就出现了 double-check双重检查式。

双重检查式(double-check)

public class Singleton {
    private static volatile Singleton singlenton;
    
    private Singleton() {}
    
    public Singlenton getInstance() {
        if (singleton == null) {
            synchronzied (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

有几个地方发生了改变：

• getInstance() 时进行了两次判断。
• Singleton 增加了 volatile 可见性关键字，volatile和synchronized不同见我之前的博文：https://blog.csdn.net/Charlven/article/details/104463842。

通过 volatile 和 两次判空结合。就可以实现线程安全了。
优点：

1. 线程安全
2. 延迟加载
3. 效率更高

可能有的小伙伴会不明白，为什么一定要两次 check，那我们来试试去掉其中一个check。

1. 去掉第一个 check：很明显的，去掉第一个check，就会全部都进入同步了。效率很慢，原因上面已经说了。
2. 去掉第二个 check：会出现并发问题。当singleton=null，同时两个线程都执行到第一个 check 时候，线程1进入sync代码块，线程2在外面等待；线程1执行完，线程2继续创建实例。就会同时创建了两个实例了。

为什么要 votatile 呢？

因为实例化 singleton 并不是一个原子性操作。JVM 可能存在着重排序。我们来看看实例化的流程：

存在重排序完了之后变成：

所以当多线程的时候，且执行顺序被重排序时，程序就会报错。详细我们来看看：

所以使用volatile的意义主要在于防止重排序的情况。避免拿到未完成初始化的对象。

静态内部类

public class Singleton {
    private Singleton() {}
    
    private static class SingletonInstance() {
        private static final Singleton singleton = new singleton(); 
    }
    
    public Singlenton getInstance() {
        return SingletonInstance.singleton;
    }
}

和饿汉式的方式类似。不过这个是通过 JVM 的方式保证了线程安全。
和饿汉式不一样的是，这个是懒加载模式的。也就是只有在 getInstance() 才去实例化。
所以静态内部类的写法跟双重检查式的优点是一致的。

1. 线程安全
2. 延迟加载，效率高。

看着似乎完美了，无可挑剔。但是静态内部类和双重检查式都存在着一个缺点：

可以被反序列化。通过反射可以创建多个实例。

所以这个时候就来一个终极推荐写法 ↓

枚举式

public enum Singleton {
    INSTANCE;
    private final App app;
    public Singleton() {
    	app = new App();
    }

	public App getInstance() {
		return app;
	}
    public void otherMethod() {
        
    }
}
---------------------------------
获取方式：
Singleton.INSTANCE.getInstance();

优点：

1. 简洁
2. 线程安全有保障
   1. 反编译可以看出都是 static代码块
   2. 在类被加载时完成初始化，加载由JVM保证线程安全
3. 防止被反序列化破坏，反序列时只能根据valueOf方法来查看，而不能新建对象。
4. 反射时是不能创建对象。

总结

单例主要就是

• 饿汉式
• 懒汉式
• 双重检查式(又名double-check)
• 静态内部类式
• 枚举式(目前最好的实现方式)

上面几种，单线程时推荐使用懒汉式。而大多数建议后 3 种实现方式。

枚举式目前可能比较少人写，但是也是极为推荐的。最后该文章是参考了极客时间某篇课程输出的。