单例模式的本质是控制实例的数量。
一、单例模式的定义：
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
二、应用场景
比如系统中需要一个类来读取properties文件中的配置，你可以创建一个类，在需要读取某项配置时new一个实例出来，但由于配置文件里的内容是一样的，系统中就就会存在多个的实例，配置文件内容少还好，如果多的话，会造成资源浪费。
此时，就需要使用到单例模式，来保证系统中最多只有一份用于读取配置文件的类。
三、单例模式的实现
3.1 饿汉模式
public class Singleton1 {
// 创建静态的成员变量，java虚拟机在初始化时创建Singleton1的实例
private final static Singleton1 INSTANCE = new Singleton1();
// 标志位，用来防止外部通过反射创建对象实例
private static boolean flag = false;
// 私有化构造方法，防止外部通过new来创建实例
private Singleton1() {
if(!flag) {
flag = true;
} else {
throw new RuntimeException("The Singleton1 instance is already exist!");
}
}
public static Singleton1 getInstance() {
return INSTANCE;
}
}
这是最常见的一种写法，但是却存在一个问题：程序一启动就会创建一个Singleton1实例，无论有没有用到它。
3.2 懒汉模式
public class Singleton2 {
// 初始化为空值，在后面需要的时候再
private static Singleton2 instance = null;
// 标志位，用来防止外部通过反射创建对象实例
private static boolean flag = false;
// 私有化构造方法，防止外部通过new来创建实例
private Singleton2() {
if(!flag) {
flag = true;
} else {
throw new RuntimeException("The Singleton2 instance is already exist!");
}
}
// 返回实例
public static Singleton2 getInstance() {
// 如果实例为空，则创建
if(null == instance) {
instance = new Singleton2();
}
return instance;
}
}
这种写法通过延时加载来解决上面的问题，在单线程系统中没有问题，但是在多线程并发访问时，则会有可能出现问题，下面做个实验来说明：
客户端类：
public class Client {
public static void main(String[] args) {
for (int i = 0;i < 100;i++) {
new Thread(() -> {
// 打印获取到的单例实例
System.out.println(Singleton2.getInstance());
}).start();
}
}
}
可以看出，Singleton2的实例已经被其他线程创建出来了，但后面的线程依然在尝试创建实例。
原因是，当前面有线程进入到了if(null == instance)后，cpu转头去执行别的任务，而其他线程同时也进了这个判断，并且创建了实例。等前面先进入的线程缓过神来后，会继续往下执行new操作（此时实例已经被创建）。
如何解决这个问题呢？
3.3 懒汉模式-改进1
public class Singleton2 {
// 初始化为空值，在后面需要的时候再
private static Singleton2 instance = null;
// 标志位，用来防止外部通过反射创建对象实例
private static boolean flag = false;
// 私有化构造方法，防止外部通过new来创建实例
private Singleton2() {
if(!flag) {
flag = true;
} else {
throw new RuntimeException("The Singleton2 instance is already exist!");
}
}
// 返回实例,给方法加锁
public synchronized static Singleton2 getInstance() {
// 如果实例为空，则创建
if(null == instance) {
instance = new Singleton2();
}
return instance;
}
}
给getInstance()方法加锁，可以有效地解决3.2中的并发问题，但带来新的问题：不管实例有没有被创建，每个线程过来时都要锁一次，在高并发的场景中，非常影响性能。
如何解决这个问题呢？
3.4 懒汉模式-改进2
public class Singleton4 {
// 初始化为空值，在后面需要的时候再
private static Singleton4 instance = null;
// 标志位，用来防止外部通过反射创建对象实例
private static boolean flag = false;
// 私有化构造方法，防止外部通过new来创建实例
private Singleton4() {
if(!flag) {
flag = true;
} else {
throw new RuntimeException("The Singleton4 instance is already exist!");
}
}
// 返回实例
public static Singleton4 getInstance() {
// 先判断实例是否为空，为空时才进入判断
if(null == instance) {
synchronized (Singleton4.class) {
// 再次判断，不存在时才真正地创建
if(null == instance) {
instance = new Singleton4();
}
}
}
return instance;
}
}
采用双重判断，避免了线程不必要地进入同步代码块。
3.5 静态内部类
public class Singleton5 {
// 标志位，用来防止外部通过反射创建对象实例
private static boolean flag = false;
// 私有化构造方法，防止外部通过new来创建实例
private Singleton5() {
if(!flag) {
flag = true;
} else {
throw new RuntimeException("The Singleton5 instance is already exist!");
}
}
// 返回实例
public static Singleton5 getInstance() {
return SingleHolder.INSTANCE;
}
// 静态内部类
private static class SingleHolder {
public static final Singleton5 INSTANCE = new Singleton5();
}
}
使用静态内部类实现时，只有当调用getInstance时，才会导致类SingleHolder类被初始化，并由虚拟机来保证它的线程安全性。
它的优势在于，getInstance()没有被同步，实现延迟初始化，而没有增加任何成本。
3.6 枚举
public enum Singleton6 {
INSTANCE;
public void method() {
System.out.println("the singleton of enum");
}
}
使用枚举来实现单例控制更加简洁，由JVM提供保障，绝对防止多次实例化，是简洁、高效、安全的一种单例实现方式。
