介绍
单例模式（Singleton Pattern）是一个比较简单的设计模式，属于创建型模式。其定义为
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例
在系统中，单例模式要求一个单例对象只能有一个实例，这类对象如果有多个实例就可能会产生一些问题，如：资源消耗过多，处理结果不一致等，一般单例会有以下使用场景
- 生成唯一 序列号
- 整个项目的共享访问点或共享数据，如Web页面计数器
- 创建一个对象实例需要消耗过多资源，如I/O和数据库连接等
在Java中，一个单例对象在一个JVM中，只会有一个实例存在。以下是单例模式结构图
- 有一个该单例对象的静态成员变量
- 私有的构造函数，只能被自身实例化
- 提供一个静态公共方法实例化对象，并访问该对象实例
单例模式实现
单例模式有两种实现方式：
- 饿汉式
- 懒汉式(延迟加载)
饿汉式
/**
* 饿汉式单例
*/
public class Singleton1 {
// 静态成员变量，在静态初始化时便实例化对象
private static final Singleton1 singleton = new Singleton1();
// 构造私有
private Singleton1(){
}
public static Singleton1 getSingletonInstance(){
return singleton;
}
}
饿汉式指的是，在类加载的时候便实例化了该单例对象，不管有没有使用，先创建了再说。这种方式是可以保证线程安全的，但是如果该对象一直没有被使用，就浪费了空间资源。
但是对于一些空间占用较大、或是只在某些特定场景才使用的单例，我们会想要在第一次使用的时候才去实例化，这时，就需要懒汉式的延迟加载
懒汉式
/**
* 懒汉式单例（非线程安全）
*/
public class Singleton2 {
private static Singleton2 singleton;
private Singleton2(){}
// 获取实例
public static Singleton2 getSingletonInstance(){
if(singleton == null){
singleton = new Singleton2();
}
return singleton;
}
}
从上面代码可以看出，懒汉式与饿汉式在于单例对象的创建时机。饿汉式是在类加载时便实例化对象，调用时无须判断直接返回即可；而懒汉式是在第一次调用时实例化，并且每次调用都需要判断是否已经实例化
但是上面的这种方式在多线程下是不安全的，多个线程同时访问getSingletonInstance()时，可能会创建多个实例，便不再是单例了。那怎么解决线程安全的问题呢？首先我们可能会想到对getSingletonInstance()方法加上synchronized关键字
/**
* 懒汉式单例（synchronized关键字线程安全）
*/
public class Singleton3 {
private static Singleton3 singleton;
private Singleton3(){}
// 获取实例
public static synchronized Singleton3 getSingletonInstance(){
if(singleton == null){
singleton = new Singleton3();
}
return singleton;
}
}
getSingletonInstance()方法加上了同步锁，增加了获取实例的时间消耗，且在多线程下可能会发生阻塞。但其实我们并不想每次获取实例的时候都去加上锁，只是想在第一次调用创建对象时保证线程安全即可
双重校验锁（DCL）
对getSingletonInstance()方法加上锁，确实能保证线程安全，却存在性能的问题。是不是要必要对整个方法加锁？还是当我检查到实例还没有创建，才去同步
双重校验锁（double-checked locking，DCL）是能解决这个问题的
/**
* 双重校验锁（double-checked locking，DCL）
*/
public class Singleton4 {
/**
* 成员变量这里会加上关键字 volatile，目的是为了防止指令重排序
*/
private static volatile Singleton4 singleton;
private Singleton4(){}
// 获取实例
public static Singleton4 getSingletonInstance(){
// 第一次校验，没有实例化才进入同步代码块
if(singleton == null){
synchronized (Singleton4.class){
// 进入同步代码块后，再判断，如果为空才创建实例
if(singleton == null){
singleton = new Singleton4();
}
}
}
return singleton;
}
}
不对方法加上锁，只对创建实例的代码加锁即可。方法中会有两次判空的操作，第一次是为了不必要的同步，为null才进入同步代码块，第二次是进入同步代码块后判断为null才创建实例
注意：这里的成员变量加上了volatile关键字
使用volatile可以保证数据的可见性，不过synchronized也是能保证同步数据的可见性的，这里使用volatile更多的目的是为了禁止Java指令重排序
静态内部类
/**
* 静态内部类
*/
public class Singleton5 {
private Singleton5(){}
// 获取实例
public static Singleton5 getSingletonInstance(){
return SingletonHolder.SINGLETON;
}
/**
* 内部类，JVM在类加载的时候，是互斥的，可以保证线程安全
*/
private static class SingletonHolder{
private static final Singleton5 SINGLETON = new Singleton5();
}
}
JVM在类加载的时候是会保证数据同步的，我们可以通过内部类来创建单例对象。第一次加载Singleton5时并不会加载内部类，不去使用内部类的时候，该内部类就不会加载。只有第一次调用getSingletonInstance()方法，会去加载内部类并实例化单例对象，这样就可以做到延迟加载和线程安全了
枚举方式
使用枚举方式来实现单例是非常简洁的，支持序列化机制，绝对防止多次实例化
/**
* 枚举方式
*/
public enum Singleton6 {
/**
* 枚举方式实现单例
*/
SINGLETON;
public void handle() {
// to do something
}
}
该单例的使用方法
public class SingletonDemo {
@Test
public void test(){
// 枚举方式
Singleton6 singleton = Singleton6.SINGLETON;
singleton.handle();
}
}
