设计模式-剖析单例模式

一、单例模式

        在进程中只有一个对象存在

二、应用场景

        最常用的就是代码中的缓存，保证数据的唯一性

三、关注的问题

        1、对象唯一性，构造函数private；2、多线程并发场景下是否支持高并发； 3、延迟加载； 4、单例的线程安全性

四、实现方法

        1、饿汉式

              饿汉式存在一个问题，会在加载SingletonWick类的时候，就在堆中实例化对象，容易造成浪费内存的情况

public class SingletonWick {
    //懒加载会直接将对象创建好
    private static final SingletonWick instance = new SingletonWick();
    private SingletonWick() {
    }

    public static SingletonWick getInstance() {
        return instance;
    }
}

      2、懒汉式

           将初始化对象延迟到使用时，但是为了保证jvm中只有一份对象，就需要在多线程场景下加锁，而锁的获取释放都需要切换到内核态才性，当单例被频繁使用时，容易成为性能瓶颈

public class SingletonLazy {
    private static SingletonLazy instance;

    private SingletonLazy() {
    }

    //当调用getInstance时，instance才会初始化，但是，为了保证单一对象，synchronized会导致性能下降
    public static synchronized SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

      3、DCL

           双重检测既支持延迟加载，同时降低了性能的影响

public class SingletonDcl {
    private static volatile SingletonDcl instance;

    private SingletonDcl() {
    }

    //双检测方法，综合上述两种方法的缺点。支持延迟加载+性能优化
    public static SingletonDcl getInstance() {
        if(instance == null) {
            synchronized (SingletonDcl.class) {
                //可能多个线程都在初始化，因此，获取锁后需要重新判断
                if (instance == null) {
                    instance = new SingletonDcl();
                }
            }
        }
        return instance;
    }
}

    4、内部类

         内部类支持延迟加载，同时不需要加锁，由jvm保证单一对象

public class SingletonInnerClass {
    private SingletonInnerClass() {}

    public static SingletonInnerClass getInstance() {
        return InnerClass.instance;
    }

    //外部内加载时，InnerClass不会加载进jvm，只有getInstance时才会加载-链接-初始化-使用
    private static class InnerClass {
        private static final SingletonInnerClass instance = new SingletonInnerClass();
    }
}

五、单例存在的问题

       1、单例对继承、多态不友好。而且单例不是面向接口开发的，当单例中缓存数据扩展变化时，需要修改的地方就多了；

       2、单例不需要创建，会在代码中直接使用，隐藏了类的继承或组合关系，当维护代码时就非常难受了；

       3、单例的测试比较难写，修改单例中数据时，ut间会相互影响

六、单例中涉及到类的加载和初始化操作

        1、类加载时机

             1> new对象、读取或设置一个类型的静态字段(final字段在编译期放入常量池中)、调用一个类型的静态方法

             2> 使用java.lang.reflect包的方法对类型进行反射调用的时，如果类没有进行过初始化，则需要先触发初始化

             3> 当初始化类的时，如果发现其父类没有进行过初始化，则需要先触发父类的初始化

             4> 当一个接口加入default默认方法时，接口的实现类初始化时，需要先加载接口

       2、双亲委派机制

             在类加载过程中，第一步是加载，主要的作用就是根据类的全限定名来获取定义此类的二进制字节流、将字节流转化为方法区的运行时数据结构、在堆上创建Class对象作为方法区此类的数据访问入口。而根据类的全限定名来获取此类的二进制流，这个动作放到java虚拟机外部去实现。实现这个动作的代码被称为“类加载器”。

             任意一个类都是绑定在类加载器上的，因此类的唯一性是由类本身和加载它的类加载器一起确定的。同一份Class文件，被不同的Class Loader加载，这两个类使用equals、isInstance、instanceof等判断都会返回false。

            Java保持的三层类加载器：启动类加载器(Bootstrap Class Loader)、扩展类加载器(Extension Class Loader)、应用程序类加载器(Application Class Loader)。

           启动类加载器：主要负责加载\lib目录下按照文件名识别的类库加载到虚拟机内存中

           扩展类加载器：加载lib\ext目录下的所有类库，允许用户将具有通用性的类库放置在ext目录以扩展Java SE的功能，用户可以直接使用扩展类加载器加载Class文件

           应用程序类加载器：加载用户路径ClassPath上所有的类库。

           双亲委派模型：启动类加载器、扩展类加载器、应用程序类加载器三者间属于组合关系。如果一个类加载器收到类加载的请求，首先不会自己尝试加载，而是委托个父类加载器去完成，每一个层次的加载器都是向上委托，因此所有的类加载时，都会委托给启动类加载器，但是每个类加载器都有自己的限定范围(文件路径)，超出他的加载范围后子类加载器才会尝试。

           双亲委派模型是Java稳定性的基石，解决了各个类加载器协作时基础类型的一致性问题(越基础的类由越上层的加载器进行加载)。

       3、类加载的过程

             1> 加载(Loading)

             2> 验证(Verification)

                   验证阶段主要是保证Class字节流中全部符合约束，运行后不会危害虚拟机自身的安全。主要包括：文件格式验证、元数据验证、字节码验证和符号引用验证。

                   格式：是否以魔数0xCAFEBABE开头、主次版本是否符合虚拟机接收范围、是否存在不被支持的常量类型等；

                   类：类是否是Object的子类、是否继承不被允许继承的类、是否实现抽象父类的所有方法、是否和父类字段方法冲突

                   Code：保证任何跳转智联都不会跳转到方法体外的字节码指令上、保证方法体重的类型转换是有效的；

                   外部：符合引用中通过字符串描述的全限定名是否能找到对应的类、符号引用中类、字段、方法的可访问性

             3> 准备(Preparation)

                  为被static修改的变量(不包含实例变量)分配内存设置类变量初始值的阶段，在JDK8以后，类变量会和Class对象一起存在Java堆中。

                  public static int value = 123; //准备阶段过后value的值为0

                  public static final int value = 123; //准备阶段过后value的值为123

             4> 解析(Resolution)

             5> 初始化(Initialization)

                   上述类加载的动作里，除了加载阶段用户应用程序可以通过自定义类加载器的方式局部参与外，其余动作都完全由Java虚拟机主导控制。而初始化阶段，Java虚拟机才真正开始执行类中编写的Java程序代码，将主导权移交给应用程序。

                   初始化阶段就是执行类构造器<clinit>方法的过程。<clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，而收集的顺序就是源文件中的顺序决定的。

                   1、静态语句块只能访问定义在静态语句块之前的变量，定义在之后的变量，是不能访问的

                   2、<clinit>的父类肯定会在子类之前执行。这个跟类的加载时机有关

                   3、Java虚拟机必须保证一个类的<clinit>()方法在多线程环境中被正确的使用。存在同步操作。

             6> 使用(Using)

                   使用阶段就是在堆中分配实例对象，而分配内存时有两种方式：当空闲内存都是连续的时，采取指针碰撞；当空闲内存非连续时，利用空闲列表来分配。而多个线程同时分配时，为保证线程安全，又采取CAS+失败重试或TLAB(Thread Local Allocation Buffer)方式。

             7> 卸载(Unloading)

 

参考：深入理解Java虚拟机第7章 虚拟机类加载机制