javamarkword_java对象结构对象头Markword

概述

对象实例由对象头、实例数据组成&＃xff0c;其中对象头包括markword和类型指针&＃xff0c;如果是数组&＃xff0c;还包括数组长度;

| 类型 | 32位JVM | 64位JVM|

| ------ ---- | ------------| --------- |

| markword | 32bit | 64bit |

| 类型指针 | 32bit |64bit &＃xff0c;开启指针压缩时为32bit |

| 数组长度 | 32bit |32bit |

header.png

compressed_header.png

可以看到

开启指针压缩时&＃xff0c;markword占用8bytes,类型指针占用8bytes&＃xff0c;共占用16bytes;

未开启指针压缩时&＃xff0c;markword占用8bytes,类型指针占用4bytes,但由于java内存地址按照8bytes对齐,长度必须是8的倍数&＃xff0c;因此会从12bytes补全到16bytes;

数组长度为4bytes,同样会进行对齐&＃xff0c;补足到8bytes;

另外从上面的截图可以看到&＃xff0c;开启指针压缩之后&＃xff0c;对象类型指针为0xf800c005,但实际的类型指针为0x7c0060028;那么指针是如何压缩的呢&＃xff1f;实际上由于java地址一定是8的倍数&＃xff0c;因此将0xf800c005*8即可得到实际的指针0x7c0060028,关于指针压缩的更多知识可参考官方文档。

markword结构

markword的结构&＃xff0c;定义在markOop.hpp文件&＃xff1a;

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)

unused:25 hash:31 -->| cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && normal object)

JavaThread*:54 epoch:2 cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && biased object)

narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object)

unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block)

[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

由于目前基本都在使用64位JVM,此处不再对32位的结构进行详细说明:

偏向锁标识位锁标识位锁状态存储内容

0

01

未锁定

hash code(31),年龄(4)

1

01

偏向锁

线程ID(54),时间戳(2),年龄(4)

无

00

轻量级锁

栈中锁记录的指针(64)

无

10

重量级锁

monitor的指针(64)

无

11

GC标记

空&＃xff0c;不需要记录信息

此处&＃xff0c;有几点要注意:

如果对象没有重写hashcode方法&＃xff0c;那么默认是调用os::random产生hashcode,可以通过System.identityHashCode获取&＃xff1b;os::random产生hashcode的规则为:next_rand &＃61; (16807seed) mod (2*31-1),因此可以使用31位存储;另外一旦生成了hashcode,JVM会将其记录在markword中&＃xff1b;

GC年龄采用4位bit存储&＃xff0c;最大为15&＃xff0c;例如MaxTenuringThreshold参数默认值就是15&＃xff1b;

当处于轻量级锁、重量级锁时&＃xff0c;记录的对象指针&＃xff0c;根据JVM的说明&＃xff0c;此时认为指针仍然是64位&＃xff0c;最低两位假定为0;当处于偏向锁时&＃xff0c;记录的为获得偏向锁的线程指针&＃xff0c;该指针也是64位&＃xff1b;

We assume that stack/thread pointers have the lowest two bits cleared.

ObjectMonitor* monitor() const {

assert(has_monitor(), "check");

// Use xor instead of &~ to provide one extra tag-bit check.

return (ObjectMonitor*) (value() ^ monitor_value);//monitor_value&＃61;2,value最右两位为10&＃xff0c;因此异或之后最右两位为0

}

JavaThread* biased_locker() const {

assert(has_bias_pattern(), "should not call this otherwise");

return (JavaThread*) ((intptr_t) (mask_bits(value(), ~(biased_lock_mask_in_place | age_mask_in_place | epoch_mask_in_place))));

//~(biased_lock_mask_in_place | age_mask_in_place | epoch_mask_in_place)为11111111111111111111110010000000&＃xff0c;计算后的结果中&＃xff0c;低10位全部为0;

}

由于java中内存地址都是8的倍数&＃xff0c;因此可以理解为最低3bit为0&＃xff0c;因此假设轻量级和重量级锁的最低2位为0是成立的&＃xff1b;但为什么偏向锁的最低10位都是0?查看markOop.hpp文件&＃xff0c;发现有这么一句话:

// Alignment of JavaThread pointers encoded in object header required by biased locking

enum { biased_lock_alignment &＃61; 2 <<(epoch_shift &＃43; epoch_bits)

//epoch_shift&＃43;epoch_bits&＃xff1d;10

};

thread.hpp中重载了operator new:

void* operator new(size_t size) { return allocate(size, true); }

// &＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61; Thread &＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;

// Support for forcing alignment of thread objects for biased locking

void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {

if (UseBiasedLocking) {

const int alignment &＃61; markOopDesc::biased_lock_alignment;//10

size_t aligned_size &＃61; size &＃43; (alignment - sizeof(intptr_t));

void* real_malloc_addr &＃61; throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)

: os::malloc(aligned_size, flags, CURRENT_PC);

void* aligned_addr &＃61; (void*) align_size_up((intptr_t) real_malloc_addr, alignment);

assert(((uintptr_t) aligned_addr &＃43; (uintptr_t) size) <&＃61;

((uintptr_t) real_malloc_addr &＃43; (uintptr_t) aligned_size),

"JavaThread alignment code overflowed allocated storage");

if (TraceBiasedLocking) {

if (aligned_addr !&＃61; real_malloc_addr)

tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,

real_malloc_addr, aligned_addr);

}

((Thread*) aligned_addr)->_real_malloc_address &＃61; real_malloc_addr;

return aligned_addr;

} else {

return throw_excpt? AllocateHeap(size, flags, CURRENT_PC)

: os::malloc(size, flags, CURRENT_PC);

}

}

如果开启了偏移锁,在创建线程时&＃xff0c;线程地址会进行对齐处理&＃xff0c;保证低10位为0

实例数据

实例数据中主要包括对象的各种成员变量&＃xff0c;包括基本类型和引用类型&＃xff1b;static类型的变量会放到java/lang/Class中&＃xff0c;而不会放到实例数据中&＃xff1b;

对于引用类型的成员(包括string)&＃xff0c;存储的指针&＃xff1b;对于基本类型&＃xff0c;直接存储内容&＃xff1b;通常会将基本类型存储在一起&＃xff0c;引用类型存储在一起&＃xff1b;

例如类Test的成员定义如下:

private static Test t1&＃61;new Test();

private Test t2;

private int a&＃61;5;

private Integer b&＃61;7;

private String c&＃61;"112";

private BigDecimal d&＃61;new BigDecimal("5");

private long e&＃61;9l;

body.png

可以看到long e、int a为基本类型&＃xff0c;存储在一起&＃xff1b;其它的引用类型存储在一起&＃xff1b;int占用4bytes,不足8bytes,自动补足到8bytes;

链接&＃xff1a;https://www.jianshu.com/p/ec28e3a59e80

原文&＃xff1a;https://www.cnblogs.com/tiancai/p/12630305.html