发布于 由admin

Java对象头Mark Word：如何存储对象哈希码（HashCode）与延迟计算机制

Java对象头Mark Word：对象哈希码存储与延迟计算机制

大家好，今天我们来深入探讨Java对象头中Mark Word的奥秘，特别是它如何存储对象的哈希码以及哈希码的延迟计算机制。这部分内容对于理解Java的内存布局、锁机制以及HashMap等数据结构的性能至关重要。

1. 对象的内存布局概览

在HotSpot虚拟机中，Java对象在内存中的布局主要由三个部分组成：

  • 对象头（Header）: 存储对象自身的运行时数据，如哈希码、GC分代年龄、锁状态标志、线程ID、偏向线程ID、时间戳等。
  • 实例数据（Instance Data）: 存储对象真正的有效信息，也就是我们在类中定义的各种字段。
  • 对齐填充（Padding）: 不是必然存在的，仅仅起占位符的作用，因为HotSpot VM的自动内存管理系统要求对象的大小必须是8字节的整数倍（对齐）。

我们今天主要关注的是对象头中的Mark Word。

2. Mark Word 的结构与状态转换

Mark Word 是一个非固定的数据结构，它的内容会随着对象的状态变化而改变。它用于存储对象的运行时数据，并且根据不同的状态，可以存储不同的信息。Mark Word的长度在32位虚拟机中是4字节，在64位虚拟机中是8字节。

下面是64位虚拟机中Mark Word的典型结构（注意，以下只是示例，具体实现可能略有差异）：

状态 标志位（锁状态） 存储内容
无锁 01 (偏向锁) 对象哈希码（HashCode）、GC分代年龄（Age）、是否是偏向锁（bias_lock）、锁标志位（lock）
偏向锁 01 (偏向锁) 偏向线程ID、时间戳（epoch）、GC分代年龄（Age）、是否是偏向锁（bias_lock）、锁标志位（lock）
轻量级锁 00 指向栈中锁记录的指针（pointer to lock record）
重量级锁 10 指向monitor对象的指针（pointer to monitor）
GC标记 11 空，用于GC标记
可偏向状态 01 (可偏向) 类指针，用于快速定位对象所属的类

注意:

  • 锁标志位（lock） 用于区分当前对象的状态，例如无锁、偏向锁、轻量级锁、重量级锁等。
  • 偏向锁标志位（bias_lock） 用于指示对象是否启用偏向锁。
  • GC分代年龄（Age） 记录对象被Minor GC扫描的次数。当达到一定阈值时，对象会晋升到老年代。
  • 指向锁记录的指针（pointer to lock record） 指向线程栈帧中的锁记录，用于支持轻量级锁。
  • 指向monitor的指针（pointer to monitor） 指向monitor对象，用于支持重量级锁。

3. 哈希码（HashCode）的存储

在无锁状态下，Mark Word 会存储对象的哈希码。Java的Object.hashCode()方法返回的哈希码就存储在这里。

为什么需要存储哈希码？

  • HashMap等数据结构: HashMap、HashSet等基于哈希表的数据结构，需要使用哈希码来快速定位对象在表中的位置。
  • 对象唯一性: 在某些情况下，哈希码可以用于判断两个对象是否相等（虽然equals()方法才是判断对象相等性的标准方式）。

哈希码的存储位置:

哈希码通常占用 Mark Word 的一部分位。具体占用的位数取决于虚拟机实现。一般情况下，会使用 Mark Word 中未被其他状态信息占用的位来存储哈希码。

4. 哈希码的延迟计算（Lazy Computation）

Java中的对象哈希码并非在对象创建时立即计算出来。而是采用一种延迟计算的机制。

延迟计算的原理：

  • 初始状态: 对象创建时，Mark Word 中哈希码的部分通常是空的（例如，全部为0）。
  • 首次使用: 当第一次调用Object.hashCode()方法时，JVM会计算对象的哈希码，并将计算结果存储到 Mark Word 中。
  • 后续使用: 后续再调用Object.hashCode()方法时，JVM直接从 Mark Word 中读取已存储的哈希码，而不需要重新计算。

延迟计算的原因：

  • 性能优化: 并非所有对象都需要哈希码。如果一个对象从未被用作HashMap的键，或者从未调用过hashCode()方法，那么计算哈希码就是一种浪费。延迟计算可以避免这种不必要的开销。
  • 避免循环依赖: 在某些情况下，计算对象的哈希码可能依赖于对象自身的某些属性。如果在对象创建时就立即计算哈希码，可能会导致循环依赖或者未初始化属性的访问。

代码示例：

下面是一个简单的代码示例，演示了哈希码的延迟计算：

public class HashCodeExample {

    public static void main(String[] args) {
        Object obj = new Object();

        // 1. 对象创建时，Mark Word 中哈希码部分是空的（或未初始化）

        // 2. 第一次调用 hashCode() 方法
        int hashCode1 = obj.hashCode();
        System.out.println("First hashCode: " + hashCode1);

        // 3. 再次调用 hashCode() 方法
        int hashCode2 = obj.hashCode();
        System.out.println("Second hashCode: " + hashCode2);

        // hashCode1 和 hashCode2 的值应该相同，说明哈希码被缓存了
        System.out.println("hashCode1 == hashCode2: " + (hashCode1 == hashCode2));
    }
}

在这个例子中，第一次调用obj.hashCode()方法时，JVM会计算obj对象的哈希码，并将其存储到obj对象的Mark Word中。第二次调用obj.hashCode()方法时，JVM直接从Mark Word中读取之前计算好的哈希码，因此hashCode1和hashCode2的值是相同的。

如何验证延迟计算？

虽然我们无法直接访问Mark Word，但是可以使用一些工具（例如JOL – Java Object Layout）来观察对象的内存布局。JOL可以打印出对象的详细内存布局信息，包括Mark Word的内容。通过观察Mark Word在调用hashCode()方法前后的变化，可以验证哈希码的延迟计算。

5. 哈希码与锁状态的冲突

当对象处于加锁状态时（例如，轻量级锁或重量级锁），Mark Word 需要存储锁的信息（指向锁记录的指针或指向monitor的指针）。这意味着 Mark Word 中用于存储哈希码的空间可能被占用。

解决方案：

当对象被加锁时，哈希码的存储有两种可能的处理方式：

  • 存储到Monitor对象中: 如果对象已经膨胀为重量级锁，那么哈希码可以存储到与对象关联的Monitor对象中。Monitor对象是重量级锁的实现基础，可以存储对象的各种状态信息，包括哈希码。
  • 临时存储到线程栈中: 如果对象是轻量级锁，哈希码可以临时存储到线程栈帧中的锁记录中。当锁释放后，再将哈希码写回 Mark Word。

对HashMap的影响：

如果一个对象在作为HashMap的键时被加锁，并且它的哈希码需要被重新计算，这可能会导致HashMap的行为出现异常。因为HashMap的哈希表是基于键的哈希码来组织的。如果键的哈希码在HashMap操作期间发生改变，那么HashMap可能无法正确地找到该键。

因此，强烈建议不要使用可变对象作为HashMap的键。如果必须使用可变对象作为键，那么需要确保对象的哈希码在整个生命周期内保持不变，或者在对象状态发生改变时，需要重新计算哈希码并更新HashMap。

6. 源码分析 (以OpenJDK为例)

虽然我们无法直接访问底层的C++代码，但可以根据现有的资料和反编译的Java代码来推测哈希码计算和存储的过程。

Object.hashCode() 的实现：

Object.hashCode() 是一个native方法，它的具体实现位于JVM的C++代码中。通常情况下，JVM会使用一个随机数生成器来为对象生成哈希码，并将哈希码存储到Mark Word中。

相关C++代码的推测：

以下是一些可能相关的C++代码片段（仅为示例，并非真实代码）：

// 在ObjectSynchronizer::fastHashCode() 方法中计算哈希码
oop ObjectSynchronizer::fastHashCode(oop obj) {
  markOop mark = obj->mark();
  // 1. 检查Mark Word中是否已经存在哈希码
  if (mark->has_identity_hash()) {
    return mark->identity_hash();
  }

  // 2. 如果没有哈希码，则生成一个新的哈希码
  int hash = os::random(); // 使用随机数生成器
  markOop new_mark = mark->set_identity_hash(hash);

  // 3. CAS更新Mark Word
  if (obj->cas_mark(mark, new_mark)) {
    return oop(hash); // 返回新的哈希码
  } else {
    // CAS失败，说明Mark Word被其他线程修改了，需要重新尝试
    return fastHashCode(obj);
  }
}

// 在markOop::set_identity_hash() 方法中设置哈希码
markOop markOop::set_identity_hash(int hash) const {
  // 根据当前的锁状态，选择合适的存储位置
  if (is_unlocked()) {
    // 无锁状态，直接将哈希码写入Mark Word
    return copy_set_identity_hash(hash);
  } else if (is_biased_locked()) {
      // 偏向锁状态，可能需要撤销偏向锁
      // ...
      return copy_set_identity_hash(hash);
  } else {
    // 加锁状态，需要将哈希码存储到Monitor对象或线程栈中
    // ...
    return this; // 返回当前的Mark Word，不修改
  }
}

这段代码展示了哈希码的计算和存储过程：

  1. 首先检查Mark Word中是否已经存在哈希码。如果存在，则直接返回已存储的哈希码。
  2. 如果Mark Word中没有哈希码，则生成一个新的哈希码。
  3. 根据当前的锁状态，选择合适的存储位置。如果对象处于无锁状态，则直接将哈希码写入Mark Word。如果对象处于加锁状态，则需要将哈希码存储到Monitor对象或线程栈中。
  4. 使用CAS操作更新Mark Word，确保线程安全。

需要注意的是，这只是一个推测性的代码示例，真实的代码可能更加复杂。

7. JOL工具的使用

JOL (Java Object Layout) 是一个用于分析Java对象内存布局的工具。 它可以帮助我们查看对象的对象头信息，包括 Mark Word 的内容。

使用JOL：

  1. 添加依赖: 在Maven或Gradle项目中，添加JOL的依赖。

    <!-- Maven -->
<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.16</version> <!-- 使用最新版本 -->
</dependency>

// Gradle
dependencies {
    implementation 'org.openjdk.jol:jol-core:0.16' // 使用最新版本
}

  2. 使用JOL打印对象布局：

    import org.openjdk.jol.info.ClassLayout;

public class JOLExample {
    public static void main(String[] args) {
        Object obj = new Object();

        System.out.println(ClassLayout.parseInstance(obj).toPrintable());

        // 调用 hashCode() 方法
        obj.hashCode();

        System.out.println("nAfter hashCode() call:n" + ClassLayout.parseInstance(obj).toPrintable());
    }
}

运行这段代码，JOL会打印出obj对象的内存布局信息。通过比较调用hashCode()方法前后的Mark Word内容，可以观察到哈希码的变化。

JOL输出示例（部分）：

OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
     ...

After hashCode() call:

OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)  <--- hashCode存储在这里
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
     ...

注意：JOL的输出可能因JVM版本和操作系统而异。

8. 对象哈希码的线程安全性

哈希码的延迟计算和存储需要保证线程安全性。这是因为多个线程可能同时调用同一个对象的hashCode()方法。

线程安全性的保证：

JVM使用CAS（Compare-and-Swap）操作来保证哈希码计算和存储的线程安全性。CAS是一种乐观锁机制，它允许多个线程同时尝试修改Mark Word。只有当Mark Word的值没有被其他线程修改时，CAS操作才能成功。如果CAS操作失败，说明Mark Word已经被其他线程修改了，当前线程需要重新尝试。

CAS操作的流程：

  1. 线程A读取Mark Word的当前值。
  2. 线程A计算新的哈希码，并创建一个新的Mark Word，其中包含新的哈希码。
  3. 线程A使用CAS操作尝试将Mark Word的当前值替换为新的Mark Word。
  4. 如果CAS操作成功，说明Mark Word没有被其他线程修改，哈希码成功存储。
  5. 如果CAS操作失败，说明Mark Word已经被其他线程修改了，线程A需要重新读取Mark Word的当前值，并重复步骤2-4。

通过CAS操作，JVM可以保证只有一个线程能够成功地将哈希码存储到Mark Word中，从而避免了并发问题。

9. 注意事项与最佳实践

  • 不可变对象作为HashMap的键： 始终使用不可变对象作为HashMap的键，以避免哈希码在HashMap操作期间发生改变。
  • 谨慎重写hashCode()和equals()： 如果你需要重写hashCode()和equals()方法，请确保它们满足以下条件：
    • 一致性： 如果两个对象相等（equals()返回true），它们的哈希码必须相同。
    • 稳定性： 对象的哈希码在整个生命周期内应该保持不变（除非对象是可变的，并且状态发生了改变）。
    • 高效性： hashCode()方法的计算应该尽可能高效，避免耗时操作。
  • 理解Mark Word的结构： 深入理解Mark Word的结构和状态转换，可以帮助你更好地理解Java的内存布局、锁机制以及HashMap等数据结构的性能。
  • 使用JOL工具： 使用JOL工具可以帮助你观察对象的内存布局，验证哈希码的延迟计算，以及分析锁的状态。

总结

今天我们深入探讨了Java对象头中Mark Word的结构和作用，重点分析了哈希码的存储和延迟计算机制。哈希码的延迟计算是一种性能优化手段，可以避免不必要的哈希码计算开销。但是，在使用哈希码时，需要注意线程安全性和对象的可变性，避免出现并发问题和HashMap行为异常。理解Mark Word对于理解Java的底层机制和性能优化至关重要。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注