---

前言

本文旨在记录近期研读Java源码的学习心得与疑难问题。由于个人理解水平有限，文中内容难免存在疏漏，恳请读者不吝指正。

Java 对象的“表”与“里”

作为系统工程师，我们要深入理解 Java 对象，必须跳出 Java 代码的范畴，进入 HotSpot VM 的 C++ 世界。在 OpenJDK中，这种设计被称为 OOP-Klass 模型：oop（Ordinary Object Pointer）指向堆中的对象实例，而 Klass 存储在元空间（Metaspace），描述对象的“本质”。

下面我们结合源码，详细剖析 instanceOopDesc 与 InstanceKlass 在内存中的“长相”。
在 HotSpot 虚拟机中，Java 对象的“表”与“里”是由 OOP-Klass 模型 支撑的。instanceOopDesc 是对象在堆中的“肉身”（存储数据），而 InstanceKlass 是对象在元空间（Metaspace）中的“灵魂”（存储元数据）。

作为程序员，我们需要从 openjdk8u/hotspot/src/share/vm/oops/ 目录下的源码出发，深度拆解它们在内存中的真实形态。

下面我们结合源码，详细剖析 instanceOopDesc 与 InstanceKlass 在内存中的“长相”。

---

1. instanceOopDesc：堆中的实例长相，堆中的“躯干”

hotspot\src\share\vm\oops\oopsHierarchy.hpp

typedef class oopDesc*                            oop;
typedef class   instanceOopDesc*            instanceOop;
typedef class   arrayOopDesc*                    arrayOop;
typedef class     objArrayOopDesc*            objArrayOop;
typedef class     typeArrayOopDesc*            typeArrayOop;

由上面oopsHierarchy.hpp 源代码可以看出 instanceOop（实际上是 instanceOopDesc）定义在 instanceOop.hpp 中，它代表了一个 Java 类的实例。其内存布局由三部分组成：对象头（Header）、实例数据（Fields）和对齐填充（Padding）。

1.1 源码定义：oopDesc 的结构

hotspot\src\share\vm\oops\instanceOop.hpp的源码如下，可以看出所有的 OOP（Ordinary Object Pointer）都继承自 oopDesc。

class instanceOopDesc : public oopDesc {
 public:
  // aligned header size.
  static int header_size() { return sizeof(instanceOopDesc)/HeapWordSize; }

  // If compressed, the offset of the fields of the instance may not be aligned.
  static int base_offset_in_bytes() {
    // offset computation code breaks if UseCompressedClassPointers
    // only is true
    return (UseCompressedOops && UseCompressedClassPointers) ?
             klass_gap_offset_in_bytes() :
             sizeof(instanceOopDesc);
  }

  static bool contains_field_offset(int offset, int nonstatic_field_size) {
    int base_in_bytes = base_offset_in_bytes();
    return (offset >= base_in_bytes &&
            (offset-base_in_bytes) < nonstatic_field_size * heapOopSize);
  }
};

class oopDesc {
  friend class VMStructs;
 private:
  volatile markOop  _mark;         // 1. Mark Word
  union _metadata {                // 2. Klass Pointer (类型指针)
    Klass*      _klass;            // 未压缩时的 64 位指针
    narrowKlass _compressed_klass;  // 开启压缩后的 32 位句柄
  } _metadata;

  // 3. 这里之后紧跟的是 Instance Data (实例变量数据)
};

内存布局长相：

1. Mark Word (8字节)：存储 HashCode、分代年龄、锁标志位（偏向、轻量、重量）。这是对象的“动态记录卡”。
2. Klass Pointer (4或8字节)：指向 InstanceKlass 的指针。如果你开启了 -XX:+UseCompressedClassPointers（JDK 8 默认开启），它占用 4 字节。
3. Instance Data：存储类中定义的成员变量。注意： 字段的排列顺序并不是代码中的定义顺序，JVM 会根据类型（long/double, int, short/char, byte/boolean）进行重排序（Field Relayout）以优化对齐。
4. Padding (对齐填充)：为了让对象大小是 8 字节的整数倍，JVM 会在末尾填充空白。

1.2 内存详细剖析

1. Mark Word (_mark)：占用 8 字节（64位机）。它是一个“复用字段”，根据锁状态不同，存储内容会动态切换。

• 无锁状态：存储 hashCode (31bit)、分代年龄 (4bit)、偏向锁标志 (1bit)、锁标志位 (2bit)。
• 重量级锁：存储指向操作系统互斥量（Monitor）的指针。

2. Klass Pointer (_metadata)：

• 如果关闭压缩指针，占用 8 字节；开启后占用 4 字节。
• 作用：让 JVM 知道这个对象是哪个类的实例。

3. 实例数据 (Fields)：

• JVM 会根据属性的宽度（long/double > int > short/char > byte/boolean）进行排列，以减少空间浪费。

4. 对齐填充 (Padding)：

• 为了 CPU 寻址效率，对象总大小必须是 8 字节的倍数。

---

2. InstanceKlass：元空间里的类描述，藏在元空间里的class“灵魂”

当一个 .class 文件被加载时，JVM 会在 Metaspace（元空间，属于本地内存）创建一个 InstanceKlass 对象。它是 C++ 层的“类对象”。

2.1 源码定义：核心成员变量

InstanceKlass 位于 hotspot/src/share/vm/oops/instanceKlass.hpp。

class InstanceKlass: public Klass {
  // 1. 类层级结构
  Klass*      _super;               // 父类
  Array<Klass*>* _local_interfaces; // 直接实现的接口

  // 2. 字段与方法（类定义的静态描述）
  ConstantPool*    _constants;      // 运行时常量池
  Array<Method*>*  _methods;        // 方法列表
  Array<u2>*       _fields;         // 字段描述信息（名称、修饰符、偏移量）

  // 3. 运行时数据
  int              _vtable_len;     // 虚方法表长度
  int              _itable_len;     // 接口方法表长度
  oop              _java_mirror;    // 指向堆中 java.lang.Class 对象的镜像
  
  // 4. 类的初始化状态
  u1               _init_state;     // allocated, loaded, linked, being_initialized, fully_initialized
};

2.2 InstanceKlass 的“动态尾巴”

InstanceKlass 在内存中是一个 连续的内存块，但它的大小是不固定的。在 InstanceKlass 结构体的末尾，紧跟着两张非常重要的表：

1. Vtable (Virtual Method Table)：

• 存储了类及其父类中所有虚方法的入口地址。
• 多态核心：invokevirtual 指令通过 vtable 索引直接跳转到具体实现的机器码。

2. Itable (Interface Method Table)：

• 存储类实现的接口方法地址。

---

3. 联动分析：对象如何找到它的类？

当我们在 Java 中调用 obj.doWork() 时，底层经历了如下寻址逻辑：

3.1 提取 Klass 指针

如果开启了指针压缩（默认开启），JVM 需要将 32 位的 narrowKlass 解压为 64 位的真实地址。
在 openjdk8u/hotspot/src/share/vm/oops/klass.inline.hpp 中：

$$Address=Base+(narrowKlass\ll Shift)$$

// 源码逻辑简述
inline Klass* Klass::decode_klass(narrowKlass v) {
  return (Klass*)(address(Universe::narrow_klass_base()) + 
                 ((uintptr_t)v << Universe::narrow_klass_shift()));
}

3.2 访问 InstanceKlass 定位方法

1. 通过 instanceOop 的头找到 InstanceKlass。
2. 定位到 InstanceKlass 内存块末尾的 Vtable 区域。
3. 根据 doWork() 在编译期确定的索引（Index），取出对应的 Method* 指针。
4. 最终跳转到该方法对应的 i2i_entry（解释执行）或 nmethod（JIT 编译后的代码）入口。

---

4. 关键差异点：InstanceKlass vs java.lang.Class

很多开发者会混淆这两个概念。作为工程师，必须理清它们的“内存长相”差异：

特性	InstanceKlass (C++ 层)	java.lang.Class (Java 层)
位置	Metaspace (Native Memory)	Java Heap
存储内容	类的所有结构化信息、Vtable、Itable	类的镜像，供 Java 代码通过反射访问
创建时机	类加载过程中的加载（Loading）阶段	类加载过程中的加载阶段末尾
静态变量	不存储（JDK 8 之后）	存储静态变量（Static Fields）

注意：在 OpenJDK 8 中，静态字段（Static Fields）是存在 java.lang.Class 对象的末尾，而不是 InstanceKlass 中。这意味着静态变量在 GC 的视角里，是作为 java.lang.Class 这个实例对象的成员存在的。

---

5. 关联剖析：它们是如何“互看”的？

作为系统工程师，最关键的是理解这两者在内存中的交互链路：

• 对象找类：通过 instanceOopDesc 中的 _metadata 指针找到 InstanceKlass。

  • 如果是压缩指针，计算公式为：Klass_Addr = Base + (_compressed_klass << Shift)。

• 类找镜像：通过 InstanceKlass 里的 _java_mirror 找到堆中的 java.lang.Class 实例（用于反射）。

• 镜像回溯：在 java.lang.Class 对象的内存布局中，有一个隐藏字段 klass 指向元空间的 InstanceKlass。

内存分布总结表

组成部分	内存区域	源码类名	包含内容
对象实例	Java 堆	instanceOopDesc	运行时状态 (Mark Word)、类指针、实例变量
类元数据	元空间	InstanceKlass	方法、常量池、Vtable/Itable、字段描述
类对象	Java 堆	java.lang.Class (mirror)	静态变量、反射入口

---

总结

• instanceOopDesc 是“数据”，它是轻量级的，为了在堆中海量存在。
• InstanceKlass 是“规约”，它是沉重的，为了实现多态和方法分发。
• 两者关系：通过 _metadata和_java_mirror 指针紧密耦合，构建了 Java 动态语言特性的底层基石。