从jvm的角度来看单例模式

最近在看jvm，发现随着自己对jvm底层的了解，现在对java代码可以说是有了全新的认识。今天就从jvm的角度来看一看以前自以为很了解的单例模式。

了解单例模式的人都知道，单例模式有两种：“饿汉模式”和“懒汉模式”。

引用一段网上对这两种模式的介绍：

“饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全。饿汉式是线程安全的，在类创建的同时就已经创建好一个静态的对象供系统使用，以后不在改变。懒汉模式的特点是加载类时比较快，但是在运行时获取对象的速度比较慢，线程不安全， 懒汉式如果在创建实例对象时不加上synchronized则会导致对象的访问不是线程安全的。所以在此推荐大家使用饿汉模式。”

笔者先给出结论“上面这段描述可以说是完全不正确，最后给出的结论还算勉强正确，为什么说勉强正确，因为我不会推荐大家使用饿汉模式，我会直接说就用饿汉模式，懒汉模式在任何情况下都不需要”。

网上这段文字的错误主要有两点

1. 懒汉模式线程不安全，如果想线程安全必须加synchronized
2. 饿汉模式在加载类时会慢

先来看一下懒汉模式，不用synchronized也能实现线程安全

先来回顾一下懒汉模式的“发展史”

懒汉模式V1.0:

package common;

public class Singleton {
    private static Singleton singleton;
    
    public static Singleton getInstance(){
        if (singleton==null) {
            singleton=new Singleton();
        }
        return singleton;
    }
}

懒汉模式V1.0看起来就很不安全，当同时有两个线程调用 getInstance()方法时，很容易让两个线程都进入if块导致new 了两次对象。

于是在某一次大会上，有砖家发布了下面这种叫做DCL(double check lock)的错误写法，因为是砖家发布的，因此这种错误写法在网上广为流传，我在公司也看到有人这么写，这种我们可以称为懒汉模式V2.0

package common;

public class Singleton {
    private static Singleton singleton;
    
    public static Singleton getInstance(){
        if (singleton==null) {
            synchronized (Singleton.class) {
                if (singleton==null) {
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

懒汉模式V2.0解决了1.0中可能会new两次对象的问题，但是依然有问题。

这里我们先引入一个概念——指令重排序：编译器或处理器为了优化程序性能而采取的对指令进行重新排序执行的一种手段。

比如:

int a=1;

int b=a+1;

int c=2;

在执行这三句代码的时候，在编译器和处理器对程序进行优化之后，可以先执行int c=2，再执行另外两句，这就是指令重排序。

但是很显然，指令重排序并不是可以随便乱排的，比如int b=a+1这句依赖了a的值，因此必须要在int a=1之后执行才能保证最终b的值是正确的。因此，指令重排序后，要保证在单个线程里，执行结果和重排序前是等效的。

这里为什么强调是单个线程呢？比如刚刚的例子，假如abc都是全局变量，我们把c=2这一句重排序到第一句，从执行这三句代码的线程的角度，执行完三句代码后abc的值和重排序之前是一致的。

但是假设现在有另外一个线程在不停的打印abc的值，那么因为重排序的关系，在打印结果里就会出现c=2而ab还没有被赋值的结果。因此，在指令重排序后，从重排序的这个线程自身来看，重排序后的代码可以看作是有序的（因为保证运行结果不变），而从其他线程的角度来看，重排序后的代码是乱序执行的。

回到我们的懒汉模式V2.0，我们现在知道了，当多线程并发的时候，假如第一个线程成功获取锁并进入if块执行singleton=new Singleton()，

这句代码我们可以看成三步操作：

1. 在堆内存中划分一个Singleton对象实体的空间
2. 初始化堆内存中对象实例的数据（字段等）
3. 将singleton变量通过指针指向生成的对象实体

这个时候因为指令重排序，可能在步骤2还没有执行完的时候，步骤3已经执行完了，

这时候singleton变量已经不为null，此时如果有并发的线程执行getInstance()方法，将获取到一个没有初始化完成的Singleton对象从而引发错误。

为了解决这个问题，我们给singleton变量添加关键字volatile得到懒汉模式V3.0:

package common;

public class Singleton {
    private static volatile Singleton singleton;
    
    public static Singleton getInstance(){
        if (singleton==null) {
            synchronized (Singleton.class) {
                if (singleton==null) {
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

这里用volatile修饰singleton并不是用了volatile的可见性，而是用了java内存模型的“先行发生”(happens-before)原则的其中一条：

Volatile变量规则:对一个volatile变量的写操作先行发生于后面对这个变量的读操作，这里的“后面”指时间上的先后顺序。

这样一来就能禁止指令重排序，确保singleton对象是在初始化完成后才能被读到。

懒汉模式V3.0可以说是懒汉模式的终极形式，经过2次修改终于线程安全了，然而并没有什么卵用，因为饿汉模式先天就没有线程安全问题，而且也并不像网上说的那样，上来就要创建实例。

饿汉模式解析：

网上一般的说法是，饿汉模式会导致程序启动慢，因为一上来就要创建实例。相信这么说的人一定是不了解java的类加载机制。先上个饿汉模式的代码：

package common;

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

可以看到new实例是直接写在了静态变量后面，还有一种写法：

package common;

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

这两种写法在编译后是完全等效的，

类的加载分为5个步骤：加载、验证、准备、解析、初始化

初始化就是执行编译后的<cinit>()方法，而<cinit>()方法就是在编译时将静态变量赋值和静态块合并到一起生成的。

所以说，“饿汉模式”的创建对象是在类加载的初始化阶段进行的，那么类加载的初始化阶段在什么时候进行呢？jvm规范规定有且只有以下7种情况下会进行类加载的初始化阶段：

1. 使用new关键字实例化对象的时候
2. 设置或读取一个类的静态字段（被final修饰，已在编译器把结果放入常量池的静态字段除外）的时候
3. 调用一个类的静态方法的时候
4. 使用java.lang.reflect包的方法对类进行反射调用的时候
5. 初始化一个类的子类（会首先初始化父类）
6. 当虚拟机启动的时候，初始化包含main方法的主类
7. 当使用jdk1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

基本来说就是只有当你以某种方式调用了这个类的时候，它才会进行初始化，而不是说jvm启动的时候就初始化，所以说假如你的单例类里只有一个getInstance()方法，那基本上就是当你从其他类调用getInstance()方法的时候才会进行初始化，这事实上和“懒汉模式”是一样的效果。而jvm本身会确保类的初始化只执行一次。

当然，也有一种可能就是单例类里除了getInstance()方法还有一些其他静态方法，这样当调用其他静态方法的时候，也会初始化实例，但是这个很容易解决，只要加个内部类就行了(这种模式叫holder pattern)：

package common;

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

这样只有当调用getInstance()方法的时候，才会初始化内部类SingletonHolder。

总结

经过以上分析，“懒汉模式”实现复杂而且没有任何独占优点，“饿汉模式”完胜。

转载至：https://www.cnblogs.com/chenliyang/p/6548374.html