码迷,mamicode.com
首页 > 其他好文 > 详细

从jvm的角度来看单例模式

时间:2017-02-03 19:46:21      阅读:166      评论:0      收藏:0      [点我收藏+]

标签:全局   puts   虚拟   饿汉式   为什么   bsp   内存   类加载   method   

最近在看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;

在执行这三句代码的时候,cpu可以先执行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()方法的时候才会进行初始化,这事实上和“懒汉模式”是一样的效果。

 

当然,也有一种可能就是单例类里除了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。

总结

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

从jvm的角度来看单例模式

标签:全局   puts   虚拟   饿汉式   为什么   bsp   内存   类加载   method   

原文地址:http://www.cnblogs.com/sheeva/p/6362893.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!