一、前言
本文主要记录使用单例模式的几种形式，并分析各自的优缺点。使用单例模式可以避免重复创建对象，以此来节省开销，首先了解一下单例模式的四大原则：
构造方法私有
以静态方法返回实例
实例唯一，尤其在多线程环境
反序列化时不会重新构造对象
二、常用单例模式介绍
常用的单例模式有：饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式，我们来逐个解释这些模式的区别。
A、饿汉模式
/**
* 懒汉模式：在类初始化时创建对象，所以不存在线程安全问题，以空间换时间
*/
public class SingleTonHungry {
private static SingleTonHungry INSTANCE = new SingleTonHungry();
private SingleTonHungry() {
}
public static SingleTonHungry getInstance() {
return INSTANCE;
}
}
B、懒汉模式
/**
* 懒汉模式：在 getInstance() 方法被调用后才创建对象，以时间换空间
* 在多个线程同时调用 getInstance() 时，就会创建多个对象，故在多线程环境下有风险
*/
public class SingleTonLazy {
private static SingleTonLazy INSTANCE = null;
private SingleTonLazy() {
}
public static SingleTonLazy getInstance() {
if (INSTANCE == null) {
return new SingleTonLazy();
}
return INSTANCE;
}
}
C、双重锁懒汉模式（Double Check Lock）
/**
* DCL模式(Double Check Lock)，这是懒汉模式的升级版
* 解决了多线程同时调用 getInstance() 产生多个对象的问题
*/
public class SingleTonDCL {
private static volatile SingleTonDCL INSTANCE = null;
private SingleTonDCL() {
}
public static SingleTonDCL getInstance() {
// 此处判空，是为了提高性能，对象不为空的情况下就不阻塞线程
if (INSTANCE == null) {
// 加锁，同步线程
synchronized (SingleTonDCL.class) {
// 若多个线程在未初始化对象时同时调用 getInstance() 方法，那么未抢占到锁的线程在得
// 到锁之后，直接去创建对象，还是会创建多个对象，所以这里也需要判断空
if (INSTANCE == null) {
return new SingleTonDCL();
}
}
}
return INSTANCE;
}
}
关于 volatile 修饰符，又是一个内容，需要理解：
参考（有例子，比较好理解）：https://www.cnblogs.com/blog-Aevin/p/9302678.html，https://www.jianshu.com/p/ccfe24b63d87
D、静态内部类模式
/**
* 静态内部类单例模式
*/
public class SingleTonStatic {
public SingleTonStatic() {
}
public static SingleTonStatic getInstance() {
return SingleTonStaticHolder.INSTANCE;
}
private static class SingleTonStaticHolder {
private static final SingleTonStatic INSTANCE = new SingleTonStatic();
}
}
静态内部类单例模式的优点：
-
延迟实例化
当一个外部类在被加载时，不会马上去加载它的静态内部类。所以这里的静态内部类 SingleTonStaticHolder 不会马上被加载，直到 getInstance() 方法被调用，才会去加载并创建 SingleTonStatic 实例。
-
保证线程安全性、实例唯一性
当 getInstance() 方法被调用时，SingleTonStaticHolder 才在 SingleTonStatic 的运行时常量池里，把符号引用替换为直接引用。这时静态对象 INSTANCE 也真正被创建，然后再被 getInstance() 方法返回出去。这和饿汉模式类似，在类初始化时就创建对象，所以不存在线程安全问题。
那么有人会问了，如果有多个线程同时访问 getInstance() 方法，会多次初始化类，然后创建多个对象吗？答案是不会的，这我们需要了解一下类的加载机制：
虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。
所以如果一个类的<clinit>()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但线程唤醒之后不会再次进入<clinit>()方法。因为在同一个加载器下，一个类只会初始化一次。)
所以静态内部类单例模式不仅能保证线程的安全性、实例的唯一性、还延迟了单例的实例化。
但是静态内部类单例模式也有一个缺点，就是无法传递参数。因为它是通过静态内部类的形式去创建单例的，所以外部就无法传递参数进去。
E、枚举模式
/**
* 枚举单例模式
*/
public enum SingleTonEnum {
INSTANCE;
}
枚举单例模式占用的内存是静态变量的两倍，所以一般都不使用enum来实现单例。
三、总结
单例有饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式这几种形式。
饿汉模式在初始化类时就创建了对象，容易造成资源浪费；懒汉模式在多线程环境下有风险；枚举模式占用内存过高。这三种模式都有明显的弊端，所以一般不去采用。
双重锁懒汉模式使用了 volatile 修饰符，在性能上会差一点点；静态内部类模式无法传递参数。但是这两种方式都能保证实例的唯一性，线程的安全性，也不会造成资源的浪费。所以我们在使用单例模式时，可以在这两种方式中酌情选择。
参考文章：https://blog.csdn.net/mnb65482/article/details/80458571
