概述
什么是单例模式？
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
【注意】
💥 单例类只能有一个实例。
💥 单例类必须自己创建自己的唯一实例。
💥 单例类必须给所有其他对象提供这一实例。
我们先来看看关于“单例模式”的以下几点：
单例意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
单例优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例；2、避免对资源的多重占用（比如写文件操作）。
单例缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
使用场景： 1、要求生产唯一序列号；2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来；3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
注意事项：getInstance()方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
单例 DEMO
接下来我们看个简单的单例设计的 Demo，我们先创建一个 Singleton 类：SingleObject.java
public class SingleObject {
//创建 SingleObject 的一个对象
private static SingleObject instance = new SingleObject();
//让构造函数为 private，这样该类就不会被实例化
private SingleObject(){}
//获取唯一可用的对象
public static SingleObject getInstance(){
return instance;
}
public void showMessage(){
System.out.println("Hello World!");
}
}然后从 singleton 类获取唯一的对象：SingletonPatternDemo.java
public class SingletonPatternDemo {
public static void main(String[] args) {
//不合法的构造函数
//编译时错误：构造函数 SingleObject() 是不可见的
//SingleObject object = new SingleObject();
//获取唯一可用的对象
SingleObject object = SingleObject.getInstance();
//显示消息
object.showMessage();
}
}我们看下执行结果：
Hello World!单例模式的实现方式
饿汉式
代码
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}说明
这种方式比较常见，典型的“饿汉式”写法。
【是否多线程安全】：是
【实现难度】：易
【优点】：没有加锁，执行效率会提高。
【缺点】：类加载时就初始化，浪费内存。
改进版：懒汉式 – 线程不安全
代码
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}说明
这种方式是大多数面试者的写法，也是教科书上的标配，但这段代码却存在一个致命的问题：当多个线程并行调用 getInstance() 的时候，就会创建多个实例。
改进版：懒汉式 – 线程安全
代码
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}说明
既然要线程安全，那就如上所述“加锁”处理！
【是否多线程安全】：是
【实现难度】：易
【优点】：第一次调用才初始化，避免内存浪费。
【缺点】：必须加锁 synchronized 才能保证单例，但加锁（加锁操作也是耗时的）会影响效率。
改进版：双重校验锁
代码
public class Singleton {
private static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}说明
为什么需要进行 2 次判断是否为空呢？
第一次判断是为了避免不必要的同步，第二次判断是确保在此之前没有其他进程进入到 synchronized 块创建了新实例。
这段代码看起来很完美，很可惜，它还是有隐患。主要在于 instance = new Singleton() 这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情：
✨ 给 instance 分配内存
✨ 调用 Singleton 的构造函数来初始化成员变量
✨ 将 instance 对象指向分配的内存空间（执行完这步 instance 就为非 null 了）
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
改进版：双检锁（volatile）
代码
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}说明
有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。
但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。
那么，有没有一种既有懒加载，又保证了线程安全，还简单的方法呢？
当然有，静态内部类，就是一种我们想要的方法。我们完全可以把 Singleton 实例放在一个静态内部类中，这样就避免了静态实例在 Singleton 类加载的时候就创建对象，并且由于静态内部类只会被加载一次，所以这种写法也是线程安全的。
终极版：静态内部类
代码
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}说明
这是比较推荐的解法，这种写法用 JVM 本身的机制保证了线程安全的问题，同时读取实例的时候也不会进行同步，没什么性能缺陷，还不依赖 JDK 版本。
枚举
代码
public enum Singleton {
INSTANCE;
}说明
这是从 Java 1.5 发行版本后就可以实用的单例方法，我们可以通过 Singleton.INSTANCE 来访问实例，这比调用 getInstance() 方法简单多了。
创建枚举默认就是线程安全的，所以不需要担心 double checked locking，而且还能防止反序列化导致重新创建新的对象。
