企业官网建设流程全解析

对象访问定位：句柄与直接指针

引言

对象创建后，Java 程序需要通过栈上的引用（reference）去操作堆中的对象。但"引用"到底如何定位到堆中的对象？这个问题看似简单，背后却涉及一个重要的设计决策：reference 到 Java 对象的访问方式。

不同的访问方式在 GC 稳定性和访问性能之间做出不同权衡。本篇将讲解两种主流的对象访问方式——句柄访问（Handle）和直接指针访问（Direct Pointer），分析它们各自的优劣，以及主流 JVM 的实现选择。

一、问题的起点：reference 指向什么？

在 Java 代码中，我们通过变量来操作对象：

Objectobj=newObject();// obj 是栈上的 referenceobj.hashCode();// 通过 reference 访问堆中对象

obj存在于 Java 栈帧的局部变量表中，它是一个引用。但这个引用的内容是什么？它存储的是堆中对象的直接地址，还是一个间接的句柄地址？这就是对象访问方式要回答的问题。

+------------------------------------------------------------------+ | 栈帧局部变量表 Java 堆 | | +------------------+ +-----------------------+ | | | obj (reference) | ---> ? | Object 实例数据 | | | +------------------+ +-----------------------+ | | | | | | 方法区 / 元空间 | | v | | +-----------------------+ | | | Object 类元数据 | | | +-----------------------+ | +------------------------------------------------------------------+ | reference 到底指向哪里？这就是访问方式要解决的问题 | +------------------------------------------------------------------+

主流的访问方式有两种：句柄访问和直接指针访问。

二、句柄访问（Handle）

2.1 工作原理

句柄访问方式下，Java 堆中会划分出一块内存作为句柄池（Handle Pool）。reference 中存储的是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的地址。

+------------------------------------------------------------------+ | 句柄访问方式 | +------------------------------------------------------------------+ | | | 栈帧 Java 堆 方法区 | | | | +----------+ +------------------+ +----------+ | | | | | 句柄池 | | | | | | ref | -----> | +------------+ | | 类元数据 | | | | | | | 实例指针 |--+--------->| (Klass) | | | +----------+ | | 类型指针 |--|---+ | | | | | +------------+ | | +----------+ | | | | | | | | 其他句柄... | | | | +--------|---------+ | | | | | | | v | | | +------------------+ | | | | 对象实例数据 |<--+ | | | (Instance Data) | | | +------------------+ | +------------------------------------------------------------------+ | 访问对象需要两次解引用：ref → 句柄 → 实例数据/类型数据 | +------------------------------------------------------------------+

2.2 代码示意

publicclassHandleAccessDemo{publicstaticvoidmain(String[]args){// 假设采用句柄访问Personp=newPerson("Alice",25);// p（reference）存储的是句柄地址，而非对象直接地址// 访问流程：// 1. 从栈中读取 p 的值 → 句柄地址 0x1000// 2. 访问句柄池 0x1000 → 获取实例指针 0x2000、类型指针 0x3000// 3. 通过实例指针 0x2000 访问堆中对象实例数据// 4. 通过类型指针 0x3000 访问方法区中 Person 类元数据p.getName();// 上述流程执行一次p.setAge(26);// 上述流程再执行一次}}

2.3 句柄访问的优点

GC 稳定性好：这是句柄访问最大的优势。当 GC 移动对象时（如复制算法、标记-整理算法），只需要更新句柄中的实例指针，而不需要修改所有指向该对象的 reference。

+------------------------------------------------------------------+ | GC 移动对象时，句柄方式只需更新句柄池 | +------------------------------------------------------------------+ | | | GC 前： | | ref ---> 句柄 [实例指针: 0x2000] ---> 对象@0x2000 | | | | GC 后（对象被移动到 0x5000）： | | | | 句柄方式： | | ref ---> 句柄 [实例指针: 0x5000] ---> 对象@0x5000 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | | 只需更新句柄池中的一处指针，reference 不变 | | | | 直接指针方式： | | ref ---> 对象@0x5000 | | ^^^^^^^^^^^^^^^^^^^^^^^ | | 需要找到所有指向 0x2000 的 reference 并全部更新为 0x5000 | +------------------------------------------------------------------+

考虑一个场景：堆中有 100 万个 reference 指向同一个对象。GC 移动该对象时：

• 句柄方式：只需修改句柄池中 1 个指针
• 直接指针方式：需要修改 100 万个 reference

2.4 句柄访问的缺点

访问速度慢：每次访问对象都需要两次指针解引用——先找到句柄，再从句柄找到对象实例。在高频访问场景下，这个开销不可忽视。

额外内存开销：句柄池本身占用堆内存。每个对象都需要一个句柄（通常 8-16 字节），对于对象数量庞大的应用，句柄池的内存开销可观。

三、直接指针访问（Direct Pointer）

3.1 工作原理

直接指针访问方式下，reference 中存储的是对象在堆中的直接地址。对象的类型数据通过对象头中的Klass Pointer来定位。

+------------------------------------------------------------------+ | 直接指针访问方式 | +------------------------------------------------------------------+ | | | 栈帧 Java 堆 方法区 | | | | +----------+ +------------------+ +----------+ | | | | | 对象头 | | | | | | ref | -----> | +------------+ | Klass | 类元数据 | | | | | | | Mark Word | | Pointer | (Klass) | | | +----------+ | +------------+ |--------->| | | | | | Klass Ptr | | +----------+ | | | +------------+ | | | | 实例数据 | | | | (Instance Data)| | | +------------------+ | +------------------------------------------------------------------+ | 访问对象只需一次解引用：ref → 对象（含对象头 + 实例数据） | +------------------------------------------------------------------+

3.2 代码示意

publicclassDirectAccessDemo{publicstaticvoidmain(String[]args){// HotSpot 采用直接指针访问Personp=newPerson("Alice",25);// p（reference）存储的是对象的直接堆地址// 访问流程：// 1. 从栈中读取 p 的值 → 对象地址 0x2000// 2. 直接访问堆中 0x2000 处的对象// - 对象头中包含 Klass Pointer → 方法区中的 Person 类元数据// - 紧跟对象头的是实例数据p.getName();// 一次解引用即可访问}}

3.3 直接指针的优点

访问速度快：只需一次指针解引用就能定位到对象实例数据。对于频繁的对象访问，省去了一次内存寻址的开销。由于对象访问是 Java 程序中最频繁的操作之一，这个优化累积效果显著。

无额外内存开销：不需要维护独立的句柄池，类型指针已包含在对象头中。

3.4 直接指针的缺点

GC 开销更大：GC 移动对象时，需要更新所有指向该对象的 reference。JVM 通过GC 根集合遍历和记忆集（Remembered Set）来找到需要更新的引用，这增加了 GC 的复杂度和时间开销。

不过，现代 GC 技术（如卡表、写屏障）已经能高效处理引用更新问题，直接指针的 GC 开销在实际中可控。

四、两种方式对比

核心权衡：句柄访问用空间换 GC 稳定性，直接指针用 GC 复杂度换访问速度。

+------------------------------------------------------------------+ | 权衡示意图 | +------------------------------------------------------------------+ | | | 访问频率 ←--- 直接指针的优势场景（高频访问） | | ^ | | | 速度 | | | ^ | | | | 直接指针 | | | | \ | | | | \ | | | | \ 交叉点 | | | | \ | | | | \ | | | | 句柄访问 | | | +-----------------------> GC 移动频率 | | | 句柄的优势场景（频繁 GC 移动） | | | | HotSpot 的选择：访问频率远高于 GC 移动频率 → 直接指针 | +------------------------------------------------------------------+

五、各 JVM 实现的选择

5.1 HotSpot JVM

HotSpot 采用直接指针访问。这是基于以下考量：

1. 访问速度优先：Java 程序中对象访问极其频繁，一次解引用的性能优势在累积后非常可观。
2. 对象头已含类型指针：Klass Pointer 存储在对象头中，无需额外的句柄中转。
3. 现代 GC 足够高效：HotSpot 的 GC 通过写屏障和卡表机制，能高效处理引用更新。

// 可以通过 JOL 验证 HotSpot 使用直接指针importorg.openjdk.jol.info.ClassLayout;publicclassHotSpotAccessDemo{publicstaticvoidmain(String[]args){Objectobj=newObject();// 打印对象地址System.out.println(ClassLayout.parseInstance(obj).toPrintable());// 对象头中 Klass Pointer 直接指向元空间中的类元数据// 证明 reference 直接指向对象，而非句柄}}

5.2 其他 JVM 实现

OpenJ9 的句柄选择：IBM 的 OpenJ9（前身 J9）历史上采用句柄访问，这与 IBM 在大型企业系统中的 GC 稳定性需求有关。但 OpenJ9 在较新版本中也引入了直接指针的优化路径，采用混合策略。

5.3 为什么 HotSpot 选择直接指针？

从统计数据看，对象访问的频率远高于 GC 移动对象的频率：

+------------------------------------------------------------------+ | 频率对比（示意） | +------------------------------------------------------------------+ | | | 对象访问次数/秒： 数百万 ~ 数千万 | | GC 移动对象次数/秒：仅在 GC 期间发生，通常每秒 < 1 次 | | | | 结论：优化高频操作（访问）比优化低频操作（GC移动）更划算 | | | | HotSpot：直接指针 → 每次访问省一次解引用 | | 代价：GC 时多花一些时间更新引用（可控） | +------------------------------------------------------------------+

HotSpot 团队认为，在典型的 Java 应用中，对象访问的频率比 GC 移动对象的频率高出几个数量级。因此，优化访问速度（直接指针）比简化 GC 引用更新（句柄）更有价值。

六、实际验证与思考

6.1 从对象头验证直接指针

importorg.openjdk.jol.info.ClassLayout;importorg.openjdk.jol.vm.VM;publicclassDirectPointerVerification{publicstaticvoidmain(String[]args){// 打印当前 JVM 的对象布局信息System.out.println(VM.current().details());Stringstr="Hello";System.out.println(ClassLayout.parseInstance(str).toPrintable());// 输出中可以看到：// 1. 对象头中有 Klass Pointer 字段// 2. reference 直接指向对象起始地址（即对象头）// 3. 没有"句柄"中间层}}

6.2 GC 移动对象时的引用更新

虽然直接指针方式下 GC 需要更新引用，但 HotSpot 通过以下机制保证效率：

1. 根集合枚举：GC 从 GC Roots（栈、全局引用等）出发，快速找到所有活跃引用。
2. OopMap（Oop Map）：JVM 在安全点记录栈帧中引用的位置，避免全栈扫描。
3. 写屏障（Write Barrier）：维护跨代/跨 Region 引用关系，避免全堆扫描。

+------------------------------------------------------------------+ | HotSpot 直接指针 + GC 引用更新机制 | +------------------------------------------------------------------+ | | | GC Roots (栈、静态字段、JNI 引用等) | | | | | | OopMap 记录引用位置 | | v | | 枚举所有活跃引用 → 更新指向移动后对象的新地址 | | | | 跨代引用：通过卡表 + 写屏障维护 | | +---+---+---+---+---+---+---+---+ | | | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 卡表（每张卡 512B） | | +---+---+---+---+---+---+---+---+ | | 正常 脏 正常 正常 脏 正常 正常 正常 | | ^ | | 只扫描脏卡对应的堆区域 | +------------------------------------------------------------------+

6.3 对开发者的启示

了解访问方式对日常开发有实际意义：

// 场景：高频缓存访问publicclassCacheAccessPattern{// 直接指针方式下，cache.get(key) 只需一次解引用// 加上 HashMap 内部的链表/树遍历privatestaticfinalMap<String,HeavyObject>cache=newHashMap<>();publicHeavyObjectget(Stringkey){// 访问链路：// 1. 局部变量 key → 直接指向 String 对象// 2. cache.get() → HashMap 内部 Node 引用 → 直接指向 Node// 3. Node.value → 直接指向 HeavyObject// 全程直接指针，无句柄中转returncache.get(key);}}

在直接指针模型下，减少间接层级（如避免不必要的包装类、减少链式引用）对性能有直接帮助。

实践要点

1. HotSpot 默认直接指针，无需配置：开发者通常无需关心访问方式，HotSpot 已做出最优选择。但理解这一机制有助于在性能分析时做出正确判断。

2. GC 移动对象不影响引用正确性：无论 GC 如何移动对象，reference 始终指向正确的对象（HotSpot 在 GC 时更新所有引用）。不要在 JNI 代码中缓存对象指针跨 GC 使用，应使用GetLocalRef/NewGlobalRef等 JNI 引用管理 API。

3. 安全点与引用更新：GC 更新引用需要安全点（Safepoint），这是 Stop-The-World 的原因之一。减少对象数量可以缩短安全点同步时间。

4. 压缩指针与访问效率：开启指针压缩（-XX:+UseCompressedOops）不仅节省内存，还减少了指针的宽度，对 CPU 缓存行利用率有正面影响。在 32GB 以下堆环境务必保持开启。

5. 跨 JVM 迁移注意：从 OpenJ9 迁移到 HotSpot（或反向）时，对象访问方式的差异可能导致相同的代码表现出不同的内存占用和 GC 行为。在做性能基准对比时需考虑这一因素。

小结

• 对象访问有句柄访问和直接指针访问两种方式，核心区别在于 reference 指向的是句柄还是对象本身。
• 句柄访问：reference → 句柄 → 对象，GC 移动对象时只需更新句柄，但每次访问多一次解引用。
• 直接指针访问：reference → 对象，访问速度最快，GC 移动对象时需更新所有引用。
• HotSpot 采用直接指针，因为对象访问频率远高于 GC 移动频率，优化访问速度收益更大。
• 对象头中的Klass Pointer使得直接指针方式也能高效访问类型数据，无需额外中转。
• 现代 GC 的OopMap、卡表、写屏障机制使直接指针的引用更新开销可控。

下一篇我们将深入 Java 中最特殊的对象——String，探讨 String 常量池的位置变迁与intern()方法的工作原理。

更多内容：JVM调优实战