Table of Contents generated with DocToc (opens new window)

• 5、单例模式升级
  • 双重检测锁定模式的懒汉式单例(Double Check Lock)
  • 静态内部类模式
  • 枚举类实现避免反射获取示例

---

5、单例模式升级

双重检测锁定模式的懒汉式单例(Double Check Lock)

static class LazySingle {

        private static volatile LazySingle INSTANCE = null;

        private LazySingle() {

        }
        //双重检测锁定模式的懒汉式单例 DCL懒汉式
        public static LazySingle getInstance() {
            if (INSTANCE == null){
                synchronized (LazySingle.class){
                    if (INSTANCE == null) {
                        INSTANCE = new LazySingle();
                        /*
                        * 上述new对象的步骤分为
                        * 1.在堆内存开辟内存空间。
                        * 2.在堆内存中实例化SingleTon里面的各个参数,初始化对象
                        * 3.把对象指向堆内存空间
                        * 上述操作不是原子性操作,
                        *
                        * 由于jvm存在乱序执行功能,
                        * 可能会发生指令重排,当执行132顺序时,
                        * 线程A还未执行2时,线程B进入第一个if判断,因为执行完了3,此时的
                        * INSTANCE已经有了内存空间地址,所以判null为false,
                        * 线程B就会直接执行到出if方法,直接返回当前这个未初始化完的对象
                        * 这就是问题所在。
                        *
                        * 所以我们需要使用volatile来修饰INSTANCE变量,使得对这个变量进行的操作
                        * 不会被进行指令重排,严格按照123的顺序执行,防止出现上述问题
                        */
                    }
                }
            }
            return INSTANCE;
        }
    }

静态内部类模式

public class StaticSingleton {
    private StaticSingleton(){}

    private static class SingleTonHolder {
        private static final StaticSingleton INSTANCE = new StaticSingleton();
    }

    public static StaticSingleton getInstance(){
        return SingleTonHolder.INSTANCE;
    }
}

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当外部类StaticSingleton第一次被加载时，并不需要去加载SingleTonHolder，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法才会导致虚拟机加载SingleTonHolder类。这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

那么，静态内部类又是如何实现线程安全的呢？首先，我们先了解下类的加载时机。

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

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

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

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

枚举类实现避免反射获取示例

在反射的Class对象中的newInstance方法中，如果要通过反射空参构造器获取枚举类对象，会出现如上错误

其原理是：

通过反编译发现，编译后的枚举类实际上的构造方法为EnumSingleDemo(String,int)

@SuppressWarnings("all")
public enum EnumSingleDemo {
    INSTANCE;
    public EnumSingleDemo getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) throws Exception {
        EnumSingleDemo instance1 = EnumSingleDemo.INSTANCE;
        //反射使用无参构造去newInstance会出现NoSuchMethodException
        Constructor<EnumSingleDemo> constructor = EnumSingleDemo.class.getDeclaredConstructor(null);

        //通过反编译发现,编译后的枚举类实际上的构造方法为EnumSingleDemo(String,int)
        //此时想通过反射获取对象,才会出现
        //IllegalArgumentException: Cannot reflectively create enum objects 异常
//        Constructor<EnumSingleDemo> constructor = EnumSingleDemo.class.getDeclaredConstructor(String.class,int.class);
        constructor.setAccessible(true);
        EnumSingleDemo instance2 = constructor.newInstance(null);
        System.out.println(instance1 == instance2);
    }
}