一、概述
单例模式目的是维护系统中全局唯一的实例化对象，并对外提供全局访问的方法。
二、示例
单例模式分为饿汉式和懒汉式两类，也叫快加载和懒加载，二者的区别在于加载时机不同。饿汉式指的是在程序初始化的时候就实例化唯一的对象，懒汉式指的是在程序执行过程中，真正需要这个实例对象的时候才去加载。下面我们分别看一下如何实现：
1. 饿汉式
public class Singleton{
private static final Singleton instance = new Singleton();
// 限制默认构造方法的访问权限
private Singleton(){}
// 提供获取唯一实例对象的方法
public static Singleton getInstance(){
return instance;
}
}
饿汉式很好理解，就是在类加载的时候就把唯一的全局对象进行实例化，由于在JVM中，每个类只会加载一次，所以这个唯一实例是线程安全的，优点不言而喻：简单粗暴、不易出错。
2. 懒汉式
public class Singleton{
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
按照上面懒汉式写法，Singleton类加载的时候，只是声明出instance，只有在调用getInstance()时才会真正地去实例化，并且在第一次执行实例化后，后续调用getInstance()都会直接返回唯一的实例对象。这种写法在单线程中没有任何问题，但是在多线程中，就肯定会出问题了，主要的问题有两个：（1）第一个线程示例化后，其他线程不是及时可见，即内存可见性无法保证；（2）多个线程可能同时判断出instance为空，就会导致多个线程都执行实例化代码。那我们可以在现有代码的基础上进行改进：
public class Singleton{
private static Singleton instance = null;
private Singleton(){}
synchronized public static Singleton getInstance(){
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
这样的写法就会防止多个线程同时执行实例化的代码，我们在getInstance方法上加一个synchronized，通过锁机制来保证线程安全。但是，每次调用getInstance()获取单例都要获取当前类的锁，就会导致所有线程变成了串行执行，效率肯定会受到影响。我们可以继续改善：
public class Singleton{
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
if(instance == null) {
synchronized(Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
现在我们可以保证只有第一次初始化示例对象的时候才会加锁，后续使用该示例对象都不会再次加锁。但是这种写法又复现了多次实例化的问题，即多个线程同时判断到instance == null，然后依次执行了实例化代码。那应该如何避免呢？答案是双重检查机制：
public class Singleton{
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
if(instance == null) {
synchronized(Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
加锁前后，我们都对instance进行了状态判断，确保只有一个线程会去实例化唯一的对象，这么设计应该是完美了。
但是，我们忽略了一个很重要的点，就是JVM和CPU会有可能会对代码指令重排，这个重排是为了提升指令的执行效率，而重排的原则是保证重排之后的指令执行结果在单线程环境下和重排之前保持结果一致。上面的instance = new Singleton();这行代码，代表着实例化一个对象的过程，这个过程整体上分为三步：1. 分配内存；2. 初始化对象；3. 将instance引用指向这块内存区域。
如果虚拟机对这三步进行了重排序，那可能会变成1 - 3 - 2的顺序，这样就可能会出现异常情况了：第一个线程成功获取到锁，并且执行了new Singleton()，当实例化对象执行到1 - 3的时候，第二个线程也调用了getInstance()方法，那么会发生什么呢？第二个线程在第一次判断时就会得到false，接着直接return instance;但这时候其实这个对象还没有被实例化，只是指定了内存区域，那第二个线程使用这个对象就会出现问题。
为了解决上面指令重排的问题，我们加入volatile关键字，来禁止虚拟机和CPU对关于instance的指令进行重排序：
public class Singleton{
private static volatile Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
if(instance == null) {
synchronized(Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
优化到这里，我们的懒汉加载模式终于大功告成，既保证了线程安全，又最大限度地保证了并行处理的速度。缺点就是逻辑判断太多，代码错综复杂，容易出错。
