《看不懂你打我系列》 之 —— 单例模式（DCL + 静态内部类实现）

定义 ： 一个类在全局范围内只有一个实例对象，程序在需要使用该类时，获取到的都是同一个实例对象
实现步骤：

• 类的内部创建一个静态的实例对象
• 类的构造方法设为private
• 提供一个静态的方法（一般命名为getInstance），获取唯一的实例对象

实现方式：

• 饿汉式单例：
  类加载的时候就直接创建出实例对象，表现的像是一个非常饥饿的汉子，迫不及待地创建出类的实例对象。因为类的加载过程是线程安全的,多线程环境下可以保证只有一个实例。但第一次加载类的时候，就会创建Singleton实例，若创建这个实例非常消耗资源，则会造成响应缓慢，且若程序很长时间没有使用这个Singleton的实例，则无疑是一种浪费

public class Singleton{
    private static Singleton instance = new Singleton();
    private Singleton(){}  //限制住
    public static Singleton getInstance(){
        return instance;
    }
}

• 懒汉式单例
  在有线程第一次获取该类的实例对象时，才进行实例化，好处是实现了延迟加载，不会占用系统资源，系统启动快，缺点是多线程情况下，可能会产生2个实例对象（可能有人说，直接在getInstance方法上加上synchronized关键字不就解决了线程安全问题吗？是可以，然而实际只需要在第一次创建实例时，保证同步即可，后续其他线程来获取实例时，是无需同步的，加上synchronizd关键字后，多个线程获取该单例时，都得依次排队等待，在并发量高的情况下，会降低性能）

public class Singleton{
    private static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

• 双重检查锁单例
  在方法体内用synchronized来做同步，可以保证只产生一个实例，也能实现延迟加载，并且只会在第一次创建实例时进行同步，看上去貌似是一个完美的解决方案

public class Singleton{
    private static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance == null){    //语句1
            synchronized(Singleton.class){     //语句2
                if(instance == null){    //语句3
                    instance = new Singleton();  //代码A
                }
            }
        }
        return instance;
    }
}

为什么要对instance == null的判断进行了两次呢？因为getInstance这个方法本身不是同步的，存在这样一种情况，线程A和线程B同时进入了getInstance方法，而此时instance是为null的，A和B会进入到语句2去竞争这个类锁，而只有一个线程会得到锁，假设A得到了锁，则B会在语句2处等待锁，A继续执行语句3，继续执行代码A，创建出实例对象，synchronized块结束，锁释放，此时B被唤醒，获得了锁，继续执行synchronized块内的代码，若此时没有语句3，则B还会再创建一个实例对象，故需要在synchronized块内再做一次instance == null的判断
然鹅…
双重检查锁并不是100%的完美，它可以在绝大部分情况下表现良好，但一旦出现问题，则是灾难性的。
双重检查锁有什么问题呢？
问题在于代码A，代码A这一行，并不是一个原子性操作，它实际包含了3步：

1. 申请内存 memory_addr = allocate()
2. 初始化对象 initializeObject(memory_addr)
3. 将内存地址赋值给instance变量 instance = memory_addr

上述3步操作，2和3 是依赖于1的(需要1生成的memory_addr作为操作数)，然而2和3之间没有依赖关系，可以保证，1一定是发生在2和3之前的，但是2和3的发生顺序则是不确定的，若JVM进行了指令重排，按照1>3>2的顺序来执行，则在执行到3时，就会存在instance变量是有值的，但是实例对象尚未进行初始化的情况，而此时若另一线程B抢走了CPU使用权，则原线程中的初始化操作被打断，instance指向的对象未完成初始化，B进入getInstance方法，执行外层的判断时，由于instance不为null，即会直接返回该instance，而该instance指向的对象是还未进行初始化，或初始化不完全的，那么此时调用它的相关方法，则会发生错误。这种隐患是由于JVM内存模型允许发生可能的指令重排导致的。而不是双重检查锁设计理论上的缺陷。
虽然发生这种情况的概率很低，但仍然有潜在的风险，那么如何解决双重检查锁的问题呢？
使用volatile关键字修饰实例对象instance即可，使用volatile关键字修饰的变量，JVM不会进行指令重排，故可以修复上述问题。或者改用静态内部类

通过静态内部类：

public class Singleton{
    private Singleton(){}  
    private static class SingletonHolder{
        private static Singleton instance = new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

加载外部类时，不会立即加载内部类，在第一次访问内部类时，才会进行加载，即第一次调用getInstance时，才会加载内部类，这样即实现了延迟加载，并且类加载的过程是线程安全的，故可以保证只存在一个实例对象，并且也不会出现双重检查锁的问题。完美！附：静态内部类单例模式的验证代码：

package com.yogurt.po;
public class PerfectSingleton {
    static{
        System.out.println("outer class is loaded");
    }
    private PerfectSingleton(){
        System.out.println("Singleton is being initialized");
    }
    private static class SingletonHolder{
        static {
            System.out.println("inner class is loaded");
        }
        private static PerfectSingleton perfectSingleton = new PerfectSingleton();
    }
    public static PerfectSingleton getInstance(){
        return SingletonHolder.perfectSingleton;
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("start to sleep");
        Thread.sleep(3000);
        PerfectSingleton singleton = PerfectSingleton.getInstance();
    }
}

代码运行结果如下：

outer class is loaded
start to sleep
inner class is loaded
Singleton is being initialized

Process finished with exit code 0

静态内部类确实在第一次调用getInstance才进行了类的加载，并生成类的实例。