Java对象头Mark Word的深度研究：锁状态、GC标记与HashCode的存储细节
大家好，今天我们深入探讨Java对象头中的Mark Word，这是理解Java并发和GC机制的关键。我们将详细分析Mark Word中锁状态、GC标记和HashCode的存储细节，并结合代码实例进行讲解。
1. 对象头概述
在Java中，每个对象在内存中都包含对象头(Object Header)。对象头主要由两部分组成：
- Mark Word: 存储对象的哈希码、GC分代年龄、锁状态标志等信息。
- Klass Pointer: 指向类的元数据指针，JVM通过这个指针确定对象所属的类。如果是数组对象，还会包含数组长度信息。
我们今天的重点是Mark Word，它占据了对象头的大部分，并且其内容会随着对象的状态变化而动态改变。
2. Mark Word的结构
Mark Word的长度在32位JVM上是4个字节，在64位JVM上是8个字节。它的结构会根据对象的锁状态以及GC的状态而变化。下面我们分别讨论这些状态下的Mark Word结构。
2.1. 无锁状态 (Unlocked)
这是对象创建时的初始状态。
| 字段 | 长度 (bits) | 说明 |
|---|---|---|
| identity_hashcode | 31 | 对象的哈希码。只有在调用 System.identityHashCode() 方法时才会计算并存储。 |
| age | 4 | GC分代年龄，用于判断对象是否应该被回收。每经过一次Minor GC，年龄加1。当年龄达到阈值（默认15），对象会被晋升到老年代。 |
| biased_lock | 1 | 偏向锁标志位，初始值为0，表示未启用偏向锁。 |
| lock | 2 | 锁标志位，无锁状态下为 01。 |
示例代码：
public class MarkWordExample {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
// 使用JOL工具查看对象头信息 (需要引入JOL依赖)
// <dependency>
// <groupId>org.openjdk.jol</groupId>
// <artifactId>jol-core</artifactId>
// <version>0.16</version>
// </dependency>
// 运行这段代码前，请确保你已经添加了JOL的依赖
// 打印对象头信息
// System.out.println(VM.current().details(obj));
// 为了避免在打印对象头前，对象被GC，导致地址发生变化，
// 我们可以先让线程休眠一段时间。
Thread.sleep(1000);
// 计算 identityHashCode
int hashCode = System.identityHashCode(obj);
System.out.println("Identity Hash Code: " + hashCode);
// 再次打印对象头信息，观察hashCode是否被存储
// System.out.println(VM.current().details(obj));
}
}这段代码首先创建一个新的 Object 对象。然后，我们使用 System.identityHashCode() 方法计算并打印对象的哈希码。再次查看对象头信息时，会发现哈希码已经被存储在Mark Word中。
注意: 上述代码需要引入JOL(Java Object Layout)依赖才能运行。JOL是一个分析Java对象内存布局的工具，我们可以使用它来查看对象头的信息。
2.2. 偏向锁状态 (Biased Locking)
偏向锁是一种优化策略，它假设锁只会被一个线程持有。当一个线程第一次访问同步代码块时，JVM会将Mark Word设置为偏向锁状态，并将线程ID记录在Mark Word中。以后该线程再次访问这个同步代码块时，不需要进行任何同步操作，从而提高性能。
| 字段 | 长度 (bits) | 说明 |
|---|---|---|
| thread | 54 | 持有偏向锁的线程ID。 |
| epoch | 2 | 偏向时间戳，用于在多线程竞争时撤销偏向锁。 |
| age | 4 | GC分代年龄。 |
| biased_lock | 1 | 偏向锁标志位，偏向锁状态下为 1。 |
| lock | 2 | 锁标志位，偏向锁状态下为 01。 |
示例代码：
public class BiasedLockExample {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
// 开启偏向锁 (JVM参数: -XX:+UseBiasedLocking)
// 默认情况下，JVM延迟开启偏向锁，可以使用 -XX:BiasedLockingStartupDelay=0 来立即开启
// 为了确保偏向锁开启，并让对象进入偏向锁状态，需要等待一段时间
Thread.sleep(5000);
Runnable task = () -> {
synchronized (obj) {
// 使用JOL查看对象头信息
// System.out.println(VM.current().details(obj));
}
};
Thread thread = new Thread(task);
thread.start();
thread.join();
// 再次查看对象头信息，观察偏向锁状态
// System.out.println(VM.current().details(obj));
}
}这段代码首先创建一个 Object 对象，然后在同步代码块中使用该对象。在开启偏向锁的情况下（需要设置JVM参数 -XX:+UseBiasedLocking 和 -XX:BiasedLockingStartupDelay=0），当线程第一次进入同步代码块时，JVM会将Mark Word设置为偏向锁状态，并将线程ID记录在Mark Word中。
2.3. 轻量级锁状态 (Lightweight Locking)
当多个线程竞争同一个锁时，偏向锁会升级为轻量级锁。线程会在自己的线程栈中创建一个锁记录(Lock Record)，然后将Mark Word复制到锁记录中。接着，线程尝试使用CAS操作将Mark Word更新为指向锁记录的指针。如果CAS操作成功，则获得锁；否则，说明有其他线程已经获得了锁，当前线程会尝试自旋等待。
| 字段 | 长度 (bits) | 说明 |
|---|---|---|
| pointer to lock record | 62 | 指向线程栈中锁记录的指针。 |
| lock | 2 | 锁标志位，轻量级锁状态下为 00。 |
示例代码：
public class LightweightLockExample {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
Runnable task = () -> {
synchronized (obj) {
// 使用JOL查看对象头信息
// System.out.println(VM.current().details(obj));
try {
Thread.sleep(100); // 模拟持有锁一段时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
// 再次查看对象头信息，观察锁状态
// System.out.println(VM.current().details(obj));
}
}这段代码创建了两个线程，它们同时竞争同一个 Object 对象的锁。当发生竞争时，偏向锁会升级为轻量级锁，线程会将Mark Word更新为指向锁记录的指针。
2.4. 重量级锁状态 (Heavyweight Locking)
如果线程自旋等待一段时间后仍然无法获得锁，轻量级锁会升级为重量级锁。重量级锁使用操作系统的互斥量(Mutex)来实现，线程需要进入阻塞状态等待锁的释放。
| 字段 | 长度 (bits) | 说明 |
|---|---|---|
| pointer to monitor | 62 | 指向Monitor对象的指针，Monitor对象由操作系统提供，用于管理锁的状态和线程的阻塞队列。 |
| lock | 2 | 锁标志位，重量级锁状态下为 10。 |
示例代码：
public class HeavyweightLockExample {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
Runnable task = () -> {
synchronized (obj) {
// 使用JOL查看对象头信息
// System.out.println(VM.current().details(obj));
try {
Thread.sleep(2000); // 模拟持有锁一段时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
Thread thread3 = new Thread(task);
Thread thread4 = new Thread(task);
Thread thread5 = new Thread(task);
Thread thread6 = new Thread(task);
Thread thread7 = new Thread(task);
Thread thread8 = new Thread(task);
Thread thread9 = new Thread(task);
Thread thread10 = new Thread(task);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
thread6.start();
thread7.start();
thread8.start();
thread9.start();
thread10.start();
thread1.join();
thread2.join();
thread3.join();
thread4.join();
thread5.join();
thread6.join();
thread7.join();
thread8.join();
thread9.join();
thread10.join();
// 再次查看对象头信息，观察锁状态
// System.out.println(VM.current().details(obj));
}
}这段代码创建了多个线程，它们同时竞争同一个 Object 对象的锁。在高并发的情况下，轻量级锁很容易升级为重量级锁，线程会进入阻塞状态等待锁的释放。增加线程数量能更快地使锁升级。
2.5. GC标记状态 (GC Marking)
在GC过程中，需要标记哪些对象是可达的，哪些对象是需要回收的。GC标记信息也会存储在Mark Word中。
| 字段 | 长度 (bits) | 说明 |
|---|---|---|
| mark word | 62/30 | GC标记信息，例如标记位、颜色等。 |
| lock | 2 | 锁标志位，GC标记状态下根据具体GC算法而定。 |
3. 锁升级流程
总结一下锁的升级流程：
- 无锁状态: 对象创建时的初始状态。
- 偏向锁: 当一个线程第一次访问同步代码块时，JVM会将Mark Word设置为偏向锁状态，并将线程ID记录在Mark Word中。
- 轻量级锁: 当多个线程竞争同一个锁时，偏向锁会升级为轻量级锁。线程会在自己的线程栈中创建一个锁记录(Lock Record)，然后将Mark Word复制到锁记录中。接着，线程尝试使用CAS操作将Mark Word更新为指向锁记录的指针。
- 重量级锁: 如果线程自旋等待一段时间后仍然无法获得锁，轻量级锁会升级为重量级锁。重量级锁使用操作系统的互斥量(Mutex)来实现，线程需要进入阻塞状态等待锁的释放。
4.HashCode的存储
正如前面提到的，HashCode并非在对象创建时就立即计算并存储。只有当第一次调用 System.identityHashCode() 方法或者调用对象的 hashCode() 方法时，才会计算HashCode并存储在Mark Word中。一旦HashCode被存储，它就会一直存在，直到对象被回收。
5.Mark Word在不同状态下的标志位总结
| 锁状态 | 锁标志位 (lock) | 偏向锁标志位 (biased_lock) | 说明 |
|---|---|---|---|
| 无锁 | 01 | 0 | 对象创建时的初始状态，或者锁被释放后的状态。 |
| 偏向锁 | 01 | 1 | 只有一个线程持有锁，可以避免CAS操作，提高性能。 |
| 轻量级锁 | 00 | 不使用 | 多个线程竞争锁，线程通过自旋等待获取锁。 |
| 重量级锁 | 10 | 不使用 | 多个线程竞争锁，线程进入阻塞状态等待锁的释放。 |
| GC标记 | 根据GC算法而定 | 不使用 | GC过程中，用于标记对象的存活状态。 |
6. 理解Mark Word的重要性
理解Mark Word的结构和状态转换对于理解Java并发和GC机制至关重要。它可以帮助我们：
- 优化并发代码: 通过了解锁的升级流程，我们可以选择合适的锁策略，避免不必要的锁竞争，提高并发性能。
- 理解GC行为: 通过了解GC标记信息在Mark Word中的存储方式，我们可以更好地理解GC的工作原理，优化GC参数，减少GC停顿时间。
- 排查内存问题: 通过分析对象头信息，我们可以诊断内存泄漏等问题。
7. 锁优化策略的简单概括
为了提高并发性能，可以使用以下锁优化策略：
- 减少锁的持有时间: 尽量缩短同步代码块的执行时间，减少锁的竞争。
- 减小锁的粒度: 将大锁分解为小锁，减少锁的冲突。
- 使用读写锁: 当读操作远多于写操作时，可以使用读写锁来提高并发性能。
- 使用CAS操作: 在某些情况下，可以使用CAS操作来代替锁，避免线程阻塞。
- 使用无锁数据结构: 例如ConcurrentHashMap, ConcurrentLinkedQueue等等。
希望今天的讲解能够帮助大家更好地理解Java对象头中的Mark Word，并在实际开发中应用这些知识。
总结：Mark Word是对象头的关键部分
Mark Word存储了锁状态、GC标记和HashCode等重要信息，理解其结构和状态转换对于理解Java并发和GC机制至关重要。通过分析Mark Word，可以优化并发代码、理解GC行为和排查内存问题。