Java Mark Word

最新推荐文章于 2025-06-15 21:29:13 发布

CrazyApes

最新推荐文章于 2025-06-15 21:29:13 发布

阅读量481

点赞数 1

CC 4.0 BY-SA版权

分类专栏：笔记 Java 文章标签： java

本文链接：https://blog.csdn.net/CrazyApes/article/details/121604807

笔记同时被 2 个专栏收录

12 篇文章

订阅专栏

Java

7 篇文章

订阅专栏

本文深入探讨了Java对象头MarkOop的结构，包括64位环境下不同锁状态的位布局，如无锁、偏向锁、轻量级锁和重量级锁。同时提到了对象头中的标识符、年龄、偏向锁标志和锁状态等关键字段，对于理解Java内存管理和并发机制至关重要。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

时间长了总是会容易遗忘的知识点

64位

|-----------------------------------------------------------------------------------------------------------|
|                                            Object Header (128 bits)                                       |
|-----------------------------------------------------------------------------------------------------------|
|                        Mark Word (64 bits)                                       |  Klass Word (64 bits)  |默认开启指针压缩       
|-----------------------------------------------------------------------------------------------------------|
|unused:25|identity_hashcode:31(56) | unused:1 | age:4 | biased_lock:1 | lock:2 01 | OOP to metadata object |  无锁
|----------------------------------------------------------------------|-----------|------------------------|
|  thread:54 |         epoch:2      | unused:1 | age:4 | biased_lock:1 | lock:2 01 | OOP to metadata object |  偏向锁
|----------------------------------------------------------------------|-----------|------------------------|
|                     ptr_to_lock_record:62                            | lock:2 00 | OOP to metadata object |  轻量锁
|----------------------------------------------------------------------|-----------|------------------------|
|                     ptr_to_heavyweight_monitor:62                    | lock:2 10 | OOP to metadata object |  重量锁
|----------------------------------------------------------------------|-----------|------------------------|
|                                                                      | lock:2 11 | OOP to metadata object |    GC
|-----------------------------------------------------------------------------------------------------------|

//  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)

markOop.hpp

~/openjdk-8-src-b132/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):
//
//  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)
//
//  - 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.

#参考文献
https://blog.csdn.net/u013837825/article/details/105759184
https://www.cnblogs.com/vincentYw/p/11972571.html