认识设计模式（一）---单例模式（6）

（一）懒汉式（静态内部类）

（1）单例类代码如下：

class Singleton06{
    //1-构造器私有化
    private Singleton06(){ }
    //2-本类内部创建对象实例（加上了volatile）
    private static volatile Singleton06 instance;
    //3-写一个静态内部类，该类中有一个静态属性
    private static class SingletonInstance{
        private static final Singleton06 INSTANCE=new Singleton06();
    }
    //4-提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    public static synchronized Singleton06 getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

（二）优缺点分析

1. 使用静态内部类完成对象实例化，这种方式采用类装载的机制来保证初始化实例时只有一个线程
2. 静态内部类方式在Singleton06类被装载时并不会立即实例化，而是在需要实例化时，才调用getInstance方法
3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化的时候，别的线程是无法进入的
4. 所以说：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高，推荐使用

（三）与懒汉式(前三个)的区别

1. 懒汉式（线程不安全）：没使用synchronized，只能在单线程下使用
2. 懒汉式（线程安全）：使用了synchronized，每次只能一个线程进入if语句，能在多线程下使用，但是效率太低
3. 懒汉式（双重检查）：使用了两个synchronized，先check进入if语句，再check进行实例化对象，但是会重复new
4. 懒汉式（静态内部类）：静态内部类实现了懒加载，避免重复new。确保线程安全，因为多线程没法new，只能取内部类里取线程的对象。确保单例的唯一性

    public static synchronized Singleton05 getInstance(){
        if(instance==null){
            synchronized (Singleton05.class){
                if(instance==null){
                    instance=new Singleton05();
                }
            }
        }
        return instance;
    }

改成了

    //3-写一个静态内部类，该类中有一个静态属性
    private static class SingletonInstance{
        private static final Singleton06 INSTANCE=new Singleton06();
    }
    //4-提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    public static synchronized Singleton06 getInstance(){
        return SingletonInstance.INSTANCE;
    }

为什么使用volatile？

volatile 是一个类型修饰符。volatile 的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略。

volatile 的特性：

• 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。（实现可见性）
• 禁止进行指令重排序。（实现有序性）
• volatile 只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性。

由于jvm存在乱序执行功能，DCL也会出现线程不安全的情况，分析如下：

instance=new Singleton05();

这个步骤，其实在jvm里面的执行分为三步：

1. 在堆内存开辟内存空间。
2. 在堆内存中实例化SingleTon里面的各个参数。
3. 把对象指向堆内存空间。

由于jvm存在乱序执行功能，所以可能在2还没执行时就先执行了3，如果此时再被切换到线程B上，由于执行了3，instance已经非空了，会被直接拿出来用，这样的话，就会出现异常。这个就是著名的DCL失效问题。

不过在JDK1.5之后，官方也发现了这个问题，故而具体化了volatile，即在JDK1.6及以后，只要定义为private volatile static SingleTon INSTANCE = null;就可解决DCL失效问题。volatile确保INSTANCE每次均在主内存中读取，这样虽然会牺牲一点效率，但也无伤大雅。

为什么使用静态内部类？

（1）实现懒加载

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。
只有当你调用getInstance方法时，才会去创建内部类，并且返回一个实例化对象

（2）确保线程安全

先了解下类的加载时机。
类加载时机：JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。

1. 遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时，对应的java代码场景为：new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。
2. 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。
3. 当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。
4. 当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的类)，虚拟机会先初始化这个类。
5. 当使用JDK 1.7等动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。
   这5种情况被称为是类的主动引用，注意，这里《虚拟机规范》中使用的限定词是"有且仅有"，那么，除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用的行列。

我们再回头看下getInstance()方法，调用的是SingletonInstance.INSTANCE，取的是SingletonInstance里的INSTANCE对象，跟上面那个DCL方法不同的是，getInstance()方法并没有多次去new对象，故不管多少个线程去调用getInstance()方法，取的都是同一个INSTANCE对象，而不用去重新创建。当getInstance()方法被调用时，SingleTonHoler才在SingleTon的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建，然后再被getInstance()方法返回出去，这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢？在《深入理解JAVA虚拟机》中，有这么一句话:

虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。如果在一个类的()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执行()方法后，其他线程唤醒之后不会再次进入()方法。同一个加载器下，一个类型只会初始化一次。)，在实际应用中，这种阻塞往往是很隐蔽的。

故而，可以看出INSTANCE在创建过程中是线程安全的，所以说静态内部类形式的单例可保证线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

（3）保证单例的唯一性

如上所述

if(instance==null){
    instance=new Singleton05();
}

DCL每次调用getInstance方法，每次实例化对象的时候都要使用new，才能获取到一个对象

private static class SingletonInstance{
    private static final Singleton06 INSTANCE=new Singleton06();
}

而静态内部类已经用new实例化了一个对象，放在这里。当你再调用getInstance方法时，不再是使用new来实例化对象，而是到内部类里面取出来一个实例化好的对象。从始至终只new了一个对象，避免了反复new的情况。

（四）懒汉式(静态内部类)的缺点

静态内部类也有着一个致命的缺点，就是传参的问题，由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，例如Context这种参数，所以，我们创建单例时，可以在静态内部类与DCL模式里自己斟酌。

（五）单例模式补充说明和使用场景

【介绍】
涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

【意图】
保证一个类仅有一个实例，并提供一个访问它的全局访问点。

【主要解决】
一个全局使用的类频繁地创建与销毁。

【何时使用】
当您想控制实例数目，节省系统资源的时候。

【如何解决】
判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

【关键代码】
构造函数是私有的。

【应用实例】
1-一个党只能有一个主席。
2-一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

【优点】
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。

【缺点】
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

【使用场景】
1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

【注意事项】
getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。