java单列模式深入分析

首先我们要先了解下单例的四大原则：

1.构造私有。
2.以静态方法或者枚举返回实例。

3.确保实例只有一个，尤其是多线程环境。

4.确保反序列换时不会重新构建对象。

我们常用的单例模式有：

饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式，我们来逐一分析下这些模式的区别。
 

单例模式在单线程下一般分为懒汉模式，和饿汉模式，总体来说，懒汉模式的优点可以突出的显现；但是当变成多线程时，饿汉模式可以很好的避免安全隐患，而懒汉模式则不可以。

1.饿汉模式：

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

饿汉模式在类被初始化时就已经在内存中创建了对象，以空间换时间，故不存在线程安全问题。

2.懒汉模式：

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

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

懒汉模式在方法被调用后才创建对象，以时间换空间，在多线程环境下存在风险。

 

3.双重锁懒汉模式(Double Check Lock)

public class Singleton {
    private static volatile Singleton instance; //1
    private Singleton (){} //2

    public static Singleton getInstance() {
        if (instance == null) {
            //刚开始所有进入这行代码的线程，instance对象都是null
            //可能是第一个进去的线程，这时候instance对象都是null
            //也可能是第一个线程之后的线程进入并执行
            synchronized (Singleton.class) {
                //尝试获取同一个对象锁的线程，尝试获取锁，获取不到就阻塞
                //锁住类名的class（这里用到了反射的知识）
                if(instance == null) {
                    //初始化操作，使用volatile关键字禁止指令重排序
                    instance = new Singleton(); //3
                }
            }
        }
        return instance;
    }
}

DCL模式的优点就是，只有在对象需要被使用时才创建，第一次判断 instance == null为了避免非必要加锁，当第一次加载时才对实例进行加锁再实例化。这样既可以节约内存空间，又可以保证线程安全。但是，由于jvm存在乱序执行功能，DCL也会出现线程不安全的情况。故使用volatile关键字修饰，具体分析如下：

 

这段代码其实是分为三步执行：

Ⅰ、给 instance分配内存

Ⅱ、调用 Singleton 的构造函数来初始化成员变量

Ⅲ、将instance对象指向分配的内存空间（执行完这步instance 就为非 null 了）， 但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

 

4.静态内部类模式

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

}

 

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

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

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

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

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

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

 

5.枚举单例

public enum SingleTon{
  INSTANCE;
        public void method(){
        //TODO
     }

枚举在java中与普通类一样，都能拥有字段与方法，而且枚举实例创建是线程安全的，在任何情况下，它都是一个单例。