开发者社区> 幸运码发放> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

java对象头信息和三种锁的性能对比

简介:
+关注继续查看

java对象头信息和三种锁的性能对比

java头的信息分析
首先为什么我要去研究java的对象头呢? 这里截取一张hotspot的源码当中的注释

这张图换成可读的表格如下

Object Header (128 bits)
Mark Word (64 bits) Klass Word (64 bits)
unused:25 identity_hashcode:31 unused:1 age:4 biased_lock:1 lock:2 OOP to metadata object 无锁
thread:54 epoch:2 unused:1 age:4 biased_lock:1 lock:2 OOP to metadata object 偏向锁
ptr_to_lock_record:62 lock:2 OOP to metadata object 轻量锁
ptr_to_heavyweight_monitor:62 lock:2 OOP to metadata object 重量锁
lock:2 OOP to metadata object GC

意思是java的对象头在对象的不同状态下会有不同的表现形式,主要有三种状态,无锁状态、加锁状态、gc标记状态。

那么我可以理解java当中的取锁其实可以理解是给对象上锁,也就是改变对象头的状态,如果上锁成功则进入同步代码块。

但是java当中的锁有分为很多种,从上图可以看出大体分为偏向锁、轻量锁、重量锁三种锁状态。

这三种锁的效率 完全不同、关于效率的分析会在下文分析,我们只有合理的设计代码,才能合理的利用锁、那么这三种锁的原理是什么? 所以我们需要先研究这个对象头。

java对象的布局以及对象头的布局
使用JOL来分析java的对象布局,添加依赖

    

        <groupId>org.openjdk.jol</groupId>
        <artifactId>jol-core</artifactId>
        <version>0.8</version>
    </dependency>

测试类

public class B {

}

public class JOLExample1 {

static  B b = new B();
public static void main(String[] args) {
    //jvm的信息
    out.println(VM.current().details());
    out.println(ClassLayout.parseInstance(b).toPrintable());
}

}

看下结果

分析结果1:整个对象一共16B,其中对象头(Object header)12B,还有4B是对齐的字节(因为在64位虚拟机上对象的大小必 须是8的倍数),

由于这个对象里面没有任何字段,故而对象的实例数据为0B?

两个问题

1、什么叫做对象的实例数据呢?

2、那么对象头里面的12B到底存的是什么呢?

首先要明白什么对象的实例数据很简单,我们可以在B当中添加一个boolean的字段,大家都知道boolean字段占 1B,然后再看结果

整个对象的大小还是没有改变一共16B,其中对象头(Object header)12B,boolean字段flag(对象的实例数据)占 1B、剩下的3B就是对齐字节。

由此我们可以认为一个对象的布局大体分为三个部分分别是:对象头(Object header)、 对象的实例数据和字节对齐

接下来讨论第二个问题,对象头为什么是12B?这个12B当中分别存储的是什么呢?(不同位数的VM对象头的长度不一 样,这里指的是64bit的vm)

首先引用openjdk文档当中对对象头的解释

上述引用中提到一个java对象头包含了2个word,并且好包含了堆对象的布局、类型、GC状态、同步状态和标识哈 希码,具体怎么包含的呢?又是哪两个word呢?

mark word为第一个word根据文档可以知他里面包含了锁的信息,hashcode,gc信息等等,第二个word是什么 呢?

klass word为对象头的第二个word主要指向对象的元数据。

假设我们理解一个对象头主要上图两部分组成(数组对象除外,数组对象的对象头还包含一个数组长度),

那么 一个java的对象头多大呢?我们从JVM的源码注释中得知到一个mark word一个是64bit,那么klass的长度是多少呢?

所以我们需要想办法来获得java对象头的详细信息,验证一下他的大小,验证一下里面包含的信息是否正确。

根据上述利用JOL打印的对象头信息可以知道一个对象头是12B,其中8B是mark word 那么剩下的4B就是klass word了,和锁相关的就是mark word了,

那么接下来重点分析mark word里面信息 在无锁的情况下markword当中的前56bit存的是对象的hashcode,那么来验证一下

先上代码:手动计算HashCode

public class HashUtil {

public static void countHash(Object object) throws NoSuchFieldException, IllegalAccessException {
    // 手动计算HashCode
    Field field = Unsafe.class.getDeclaredField("theUnsafe");
    field.setAccessible(true);
    Unsafe unsafe = (Unsafe) field.get(null);
    long hashCode = 0;
    for (long index = 7; index > 0; index--) {
        // 取Mark Word中的每一个Byte进行计算
        hashCode |= (unsafe.getByte(object, index) & 0xFF) << ((index - 1) * 8);
    }
    String code = Long.toHexString(hashCode);
    System.out.println("util-----------0x"+code);
}

}

public class JOLExample2 {

public static void main(String[] args) throws Exception {
    B b = new B();
    out.println("befor hash");
    //没有计算HASHCODE之前的对象头
    out.println(ClassLayout.parseInstance(b).toPrintable());
    //JVM 计算的hashcode
    out.println("jvm------------0x"+Integer.toHexString(b.hashCode()));
    HashUtil.countHash(b);
    //当计算完hashcode之后,我们可以查看对象头的信息变化
    out.println("after hash");
    out.println(ClassLayout.parseInstance(b).toPrintable());

}

}

分析结果3:

1-----上面没有进行hashcode之前的对象头信息,可以看到的56bit没有值,打印完hashcode之后就有值了,为什 么是1-7B,不是0-6B呢?因为是小端存储。

其中两行是我们通过hashcode方法打印的结果,第一行是我根据1-7B的信息计算出来的 hashcode,所以可以确定java对象头当中的mark work里面的后七个字节存储的是hashcode信息,

那么第一个字节当中的八位分别存的 就是分带年龄、偏向锁信息,和对象状态,这个8bit分别表示的信息如下图(其实上图也有信息),这个图会随着对象状态改变而改变, 下图是无锁状态下

关于对象状态一共分为五种状态,分别是无锁、偏向锁、轻量锁、重量锁、GC标记,

那么2bit,如何能表示五种状 态(2bit最多只能表示4中状态分别是:00,01,10,11),

jvm做的比较好的是把偏向锁和无锁状态表示为同一个状态,然 后根据图中偏向锁的标识再去标识是无锁还是偏向锁状态。

什么意思呢?写个代码分析一下,在写代码之前我们先记得 无锁状态下的信息00000001,然后写一个偏向锁的例子看看结果

public static void main(String[] args) throws Exception {

//-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0
B b = new B();
out.println("befor lock");
out.println(ClassLayout.parseInstance(b).toPrintable());
synchronized (b){
    out.println("lock ing");
    out.println(ClassLayout.parseInstance(b).toPrintable());
}
out.println("after lock");
out.println(ClassLayout.parseInstance(b).toPrintable());

}

上面这个程序只有一个线程去调用sync方法,故而讲道理应该是偏向锁,但是此时却是轻量级锁

而且你会发现最后输出的结果(第一个字节)依 然是00000001和无锁的时候一模一样,其实这是因为虚拟机在启动的时候对于偏向锁有延迟,

比如把上述代码当中加上 睡眠5秒的代码,结果就会不一样了,

public static void main(String[] args) throws Exception {

    //-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0
    Thread.sleep(5000);
    B b = new B();
    out.println("befor lock");
    out.println(ClassLayout.parseInstance(b).toPrintable());
    synchronized (b){
        out.println("lock ing");
        out.println(ClassLayout.parseInstance(b).toPrintable());
    }
    out.println("after lock");
    out.println(ClassLayout.parseInstance(b).toPrintable());
}

结果变成00000101.当然为了方便测试我们也可以直接通过JVM的参数来禁用延迟

-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0

结果是和睡眠5秒一样的.

想想为什么偏向锁会延迟?因为启动程序的时候,jvm会有很多操作,包括gc等等,jvm刚运行时存在大量的同步方法,很多都不是偏向锁,

而偏向锁升级为轻/重量级锁的很费时间和资源,因此jvm会延迟4秒左右再开启偏向锁.

那么为什么同步之前就是偏向锁呢?我猜想是jvm的原因,目前还不清楚.

需要注意的after lock,退出同步后依然保持了偏向信息

然后看下轻量级锁的对象头

static A a;

public static void main(String[] args) throws Exception {
    a = new A();
    out.println("befre lock");
    out.println(ClassLayout.parseInstance(a).toPrintable());
    synchronized (a){
        out.println("lock ing");
        out.println(ClassLayout.parseInstance(a).toPrintable());
    }
    out.println("after lock");
    out.println(ClassLayout.parseInstance(a).toPrintable());
}

看结果:

关于重量锁首先看对象头

static A a;

public static void main(String[] args) throws Exception {
    //Thread.sleep(5000);
    a = new A();
    out.println("befre lock");
    out.println(ClassLayout.parseInstance(a).toPrintable());//无锁

    Thread t1= new Thread(){
        public void run() {
            synchronized (a){
                try {
                    Thread.sleep(5000);
                    System.out.println("t1 release");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    t1.start();
    Thread.sleep(1000);
    out.println("t1 lock ing");
    out.println(ClassLayout.parseInstance(a).toPrintable());//轻量锁
    sync();
    out.println("after lock");
    out.println(ClassLayout.parseInstance(a).toPrintable());//重量锁
    System.gc();
    out.println("after gc()");
    out.println(ClassLayout.parseInstance(a).toPrintable());//无锁---gc
}

public  static  void sync() throws InterruptedException {
    synchronized (a){
        System.out.println("t1 main lock");
        out.println(ClassLayout.parseInstance(a).toPrintable());//重量锁
    }
}

看结果

 由上述实验可总结下图:

性能对比偏向锁和轻量级锁:

public class A {

int i=0;

public synchronized void parse(){
    i++;
    
}
//JOLExample6.countDownLatch.countDown();

}

执行1000000000L次++操作

public class JOLExample4 {

public static void main(String[] args) throws Exception {
    A a = new A();
    long start = System.currentTimeMillis();
    //调用同步方法1000000000L 来计算1000000000L的++,对比偏向锁和轻量级锁的性能
    //如果不出意外,结果灰常明显
    for(int i=0;i<1000000000L;i++){
        a.parse();
    }
    long end = System.currentTimeMillis();
    System.out.println(String.format("%sms", end - start));

}

}

此时根据上面的测试可知是轻量级锁,看下结果

大概16秒

然后我们让偏向锁启动无延时,在启动一次

-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0
再看下结果

只需要2秒,速度提升了很多

再看下重量级锁的时间

static CountDownLatch countDownLatch = new CountDownLatch(1000000000);

public static void main(String[] args) throws Exception {
    final A a = new A();

    long start = System.currentTimeMillis();

    //调用同步方法1000000000L 来计算1000000000L的++,对比偏向锁和轻量级锁的性能
    //如果不出意外,结果灰常明显
    for(int i=0;i<2;i++){
        new Thread(){
            @Override
            public void run() {
                while (countDownLatch.getCount() > 0) {
                    a.parse();
                }
            }
        }.start();
    }
    countDownLatch.await();
    long end = System.currentTimeMillis();
    System.out.println(String.format("%sms", end - start));

}

看下结果,大概31秒,

可以看出三种锁的消耗是差距很大的,这也是1.5以后synchronized优化的意义

 需要注意的是如果对象已经计算了hashcode就不能偏向了

static A a;

public static void main(String[] args) throws Exception {
    Thread.sleep(5000);
    a= new A();
    a.hashCode();
    out.println("befor lock");
    out.println(ClassLayout.parseInstance(a).toPrintable());
    synchronized (a){
        out.println("lock ing");
        out.println(ClassLayout.parseInstance(a).toPrintable());
    }
    out.println("after lock");
    out.println(ClassLayout.parseInstance(a).toPrintable());
}

看下结果

原文地址https://www.cnblogs.com/lusaisai/p/12748869.html

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Java对象与Java类(下)
Java对象与Java类(下)
732 0
Java对象与Java类(上)
Java对象与Java类(上)
59 0
Java入门 - 语言基础 - 04.对象和类
Java作为一种面向对象语言。支持以下基本概念: - 多态 - 继承 - 封装 - 抽象 - 类 - 对象 - 实例 - 方法 - 重载 本节我们重点研究对象和类的概念。
244 0
Java对象和类
Java作为一种面向对象语言,支持以下基本概念 多态,继承,封装,抽象,类,对象,实例,方法,重载。 本节我们重点研究对象和类的概念。 对象,对象是类的一个实力,有状态和行为,类如,一条狗是一个对象,它的状态有颜色,名字,品种;行为有:摇尾巴,叫,吃等 类,类是一个模板,它描述一类对象的行为和状态。
746 0
《21天学通Java(第7版)》—— 1.3 对象和类
面向对象编程是基于现实世界的情况进行建模的,对象由多种更小的对象构成。 然而,组合对象只是面向对象编程的一个方面,另一个重要特征是使用类。 类是用于创建对象的模板。使用同一个类创建的每个对象都具有相似的特性。
1174 0
《21天学通Java(第6版)》—— 1.3 对象和类
面向对象编程是基于现实世界的情况进行建模的,对象由多种更小的对象构成。
1358 0
JAVA 入坑教程 | 对象和类
Java 对象和类 Java作为一种面向对象语言。支持以下基本概念: 继承 封装 抽象 类 对象 实例 方法 重载 本节我们重点研究对象和类的概念: 对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。
1032 0
五分钟带你玩转多线程(一)java多线程基础知识简介
线程概念 进程:是一个执行中的程序,如打开网易云音乐,网易云音乐就是一个进程 线程:是进程的组成,一个进程包含多个线程,是jvm最小调度单元。如网易云音乐听歌是一个线程,评价是一个线程。
47 0
+关注
幸运码发放
阿里云优惠码阿里云推荐券bieryun.com
171
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载