Java对象头

下载Hotspot源码

官网链接：http://hg.openjdk.java.net/ 下载较慢，不翻墙基本上下不了
推荐的下载方式, 去https://gitee.com/下载，搜索Hotspot，找一个即可

对象头组成（MarkWork、对象类型指针）

[oop.hpp文件：hotspot/src/share/vm/oops/oop.hpp]
class oopDesc {
friend class VMStructs;
private:
volatile markOop _mark; // MarkWord指针，本文重点
//联合体，c的小知识，一种特殊结构体，长度为字段最大，且其对齐方式要适合于联合体中所有类型的成员。
union _metadata {
Klass* _klass; // 元数据指针，未开启指针压缩使用
narrowKlass _compressed_klass;// 元数据指针，开启指针压缩使用
} _metadata;
…
}

MarkWord

[markOop.hpp文件：hotspot/src/share/vm/oops/markOop.hpp]
// The markOop describes the header of an object.
//
// Note that the mark is not a real oop but just a word.
// It is placed in the oop hierarchy for historical reasons.
//
// Bit-format of an object header (most significant first, big endian layout below):
// 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)
//
// - hash contains the identity hash value: largest value is
// 31 bits, see os::random(). Also, 64-bit vm’s require
// a hash value no bigger than 32 bits because they will not
// properly generate a mask larger than that: see library_call.cpp
// and c1_CodePatterns_sparc.cpp.
//
// - the biased lock pattern is used to bias a lock toward a given
// thread. When this pattern is set in the low three bits, the lock
// is either biased toward a given thread or “anonymously” biased,
// indicating that it is possible for it to be biased. When the
// lock is biased toward a given thread, locking and unlocking can
// be performed by that thread without using atomic operations.
// When a lock’s bias is revoked, it reverts back to the normal
// locking scheme described below.
//
// Note that we are overloading the meaning of the “unlocked” state
// of the header. Because we steal a bit from the age we can
// guarantee that the bias pattern will never be seen for a truly
// unlocked object.
//
// Note also that the biased state contains the age bits normally
// contained in the object header. Large increases in scavenge
// times were seen when these bits were absent and an arbitrary age
// assigned to all biased objects, because they tended to consume a
// significant fraction of the eden semispaces and were not
// promoted promptly, causing an increase in the amount of copying
// performed. The runtime system aligns all JavaThread* pointers to
// a very large value (currently 128 bytes (32bVM) or 256 bytes (64bVM))
// to make room for the age bits & the epoch bits (used in support of
// biased locking), and for the CMS “freeness” bit in the 64bVM (+COOPs).
//
// [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
//
// We assume that stack/thread pointers have the lowest two bits cleared.

class BasicLock;
class ObjectMonitor;
class JavaThread;

class markOopDesc: public oopDesc {
private:
// Conversion
uintptr_t value() const { return (uintptr_t) this; }
}
翻译下来可以总结为下面这张图

enum { locked_value = 0, 0 00
unlocked_value = 1, 0 01
monitor_value = 2, 0 10
marked_value = 3, 0 11
biased_lock_pattern = 5 1 01
};
// 对应最后三位

1. 对象没有加锁的时候，lock标志位0 01 包含哈希值、年龄分代和偏向锁标志位等
2. 当对象被施加偏向锁的时候，哈希值和一部分无用内存会转换成锁主人的无用信息，以及加锁的时间戳，以及加锁的时间戳epoch