Java 对象头那点事


概览

Java 对象头那点事


  • 对象头
    存放:关于堆对象的布局、类型、GC状态、同步状态和标识哈希码的基本信息。Java对象和vm内部对象都有一个共同的对象头格式。
    (后面做详细介绍)

  • 实例数据
    存放:类的数据信息,父类的信息,对象字段属性信息。
    如果对象有属性字段,则这里会有数据信息。如果对象无属性字段,则这里就不会有数据。
    根据字段类型的不同占不同的字节,例如boolean类型占1个字节,int类型占4个字节等等;

  • 对齐填充
    存放:为了字节对齐,填充的数据,不是必须的。
    默认情况下,Java虚拟机堆中对象的起始地址需要对齐至8的倍数。
    假如对象头大小为12,实例数据大小为5,最近且大于12+5的8的倍数值是24,则对齐补充大小为:24-12-5=7。


为什么需要对象填充?

字段内存对齐的其中一个原因,是让字段只出现在同一CPU的缓存行中。如果字段不是对齐的,那么就有可能出现跨缓存行的字段。也就是说,该字段的读取可能需要替换两个缓存行,而该字段的存储也会同时污染两个缓存行。这两种情况对程序的执行效率而言都是不利的。其实对其填充的最终目的是为了计算机高效寻址。

对象头

mark word

OpenJDK(JDK8)地址:https://github.com/openjdk/jdk
根据OpenJDK 官方源码中MarkOop.hpp文件中给的注释介绍,可以大概看出mark word的组成。

MarkOop.hpp中的注释1:

32 bits: --------            hash:25 ------------>| age:4    biased_lock:1 lock:2 (normal object)            JavaThread*:23 epoch:2 age:4    biased_lock:1 lock:2 (biased object)            size:32 ------------------------------------------>| (CMS free block)            PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object)  64 bits: --------            unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)            JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)            PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)            size:64 ----------------------------------------------------->| (CMS free block) 

MarkOop.hpp中的注释2:

    [JavaThread* | epoch | age | 1 | 01]       lock is biased toward given thread     [0           | epoch | age | 1 | 01]       lock is anonymously biased    - the two lock bits are used to describe three states: locked/unlocked and monitor.      [ptr             | 00]  locked             ptr points to real header on stack     [header      | 0 | 01]  unlocked           regular object header     [ptr             | 10]  monitor            inflated lock (header is wapped out)     [ptr             | 11]  marked             used by markSweep to mark an object                                                not valid at any other time 

MarkOop.hpp中的源码1:

  enum { age_bits                 = 4,          lock_bits                = 2,          biased_lock_bits         = 1,          max_hash_bits            = BitsPerWord - age_bits - lock_bits - biased_lock_bits,          hash_bits                = max_hash_bits > 31 ? 31 : max_hash_bits,          cms_bits                 = LP64_ONLY(1) NOT_LP64(0),          epoch_bits               = 2   }; 

如图:
Java 对象头那点事


MarkOop.hpp中的源码2:

  enum { locked_value             = 0,          unlocked_value           = 1,          monitor_value            = 2,          marked_value             = 3,          biased_lock_pattern      = 5   }; 
  • locked_value
    轻量级锁状态值,mark word 最后2位为00,转为10进制为0。
  • unlocked_value
    无锁状态值,mark word 最后3位为001,转为10进制为1。
  • monitor_value
    重量级锁状态值,mark word 最后2位为10,转为10进制为2。
  • marked_value
    mark word 最后2位为11,转为10进制为3。
    作用比较复杂,
    1:当锁升级为重量级锁的过程中,会将markword设置为这个值。
    2:当对象GC时也要使用这个值。

markOop.hpp部分源码如下:

  // 仅用于存储到Lock Record中,用来表示锁正在使用重量级监视器(轻量级锁膨胀为重量级锁之前会这么做)   static markOop unused_mark() {     return (markOop) marked_value;   }    // age operations   markOop set_marked()   { return markOop((value() & ~lock_mask_in_place) | marked_value); }   markOop set_unmarked() { return markOop((value() & ~lock_mask_in_place) | unlocked_value); } 
  • biased_lock_pattern
    偏向锁状态值,mark word 最后3位为101,转为10进制为5。

markOop.cpp中还有以下代码,用以判断当前markword处于哪种锁状态:

  // 轻量级锁   bool is_locked()   const {     return (mask_bits(value(), lock_mask_in_place) != unlocked_value);   }   // 偏向锁   bool is_unlocked() const {     return (mask_bits(value(), biased_lock_mask_in_place) == unlocked_value);   }   // marked   bool is_marked()   const {     return (mask_bits(value(), lock_mask_in_place) == marked_value);   }   // 无锁   bool is_neutral()  const { return (mask_bits(value(), biased_lock_mask_in_place) == unlocked_value); }   // 膨胀时 markOop 的特殊临时状态。 在锁外查看标记的代码需要考虑到这一点。   bool is_being_inflated() const { return (value() == 0); }   // 锁对象处于升级为重量级锁的过程中   static markOop INFLATING() { return (markOop) 0; } 

为什么对象头分代占4bit
因为对象经过15次GC就会被放入老年代,而15转化为二进制就是1111,干好占4bit.


epoch的作用
抄自于:http://www.itqiankun.com/article/bias-lock-epoch-effect

其本质是一个时间戳,代表了偏向锁的有效性,epoch存储在可偏向对象的MarkWord中。

①:除了对象中的epoch,对象所属的类class信息中,也会保存一个epoch值。

②:每当遇到一个全局安全点时(这里的意思是说批量重偏向没有完全替代了全局安全点,全局安全点是一直存在的),比如要对class C 进行批量再偏向,则首先对 class C中保存的epoch进行增加操作,得到一个新的epoch_new。

③:然后扫描所有持有 class C 实例的线程栈,根据线程栈的信息判断出该线程是否锁定了该对象,仅将epoch_new的值赋给被锁定的对象中,也就是现在偏向锁还在被使用的对象才会被赋值epoch_new。

④:退出安全点后,当有线程需要尝试获取偏向锁时,直接检查 class C 中存储的 epoch 值是否与目标对象中存储的 epoch 值相等, 如果不相等,则说明该对象的偏向锁已经无效了(因为(3)步骤里面已经说了只有偏向锁还在被使用的对象才会有epoch_new,这里不相等的原因是class C里面的epoch值是epoch_new,而当前对象的epoch里面的值还是epoch),此时竞争线程可以尝试对此对象重新进行偏向操作。

klass point

元数据指针class pointer,即指向方法区的instanceKlass实例(虚拟机通过这个指针来群定这个对象是哪个类的实例)。

oop.hpp中的源码:

class oopDesc {   friend class VMStructs;  private:   volatile markOop  _mark;   union _metadata {     Klass*      _klass;     narrowKlass _compressed_klass;   } _metadata; 

length field

该属性只有数组对象才有,用以表示数组的长度。

arrayOop.hpp中有这么一段注释:

// The layout of array Oops is: // //  markOop //  Klass*    // 32 bits if compressed but declared 64 in LP64. //  length    // shares klass memory or allocated after declared fields. 

总结

可能面试的时候会被问到这个问题:为什么一个对象可以当成一把锁?
这方面可以与上文中提到的对象头、markword 进行回答即可。

发表评论

相关文章