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

﹏ヽ暗。殇╰゛Y 2021-12-09 15:29 231阅读 0赞

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

*  类的内部创建一个静态的实例对象
 *  类的构造方法设为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`才进行了类的加载，并生成类的实例。