JDK 27 Cuts Object Header Overhead by 33% and Reduces CPU Usage by Up to 30%

What is JEP 534

JEP 534, titled Compact Object Headers by Default, changes the HotSpot JVM object header layout to a compact form and makes it the default starting with JDK 27.

Object header layout

On 64‑bit architectures the classic object header occupies 96 bits (12 bytes): a 64‑bit Mark Word and a 32‑bit Class Pointer.

┌───────────────────────┬───────────────┐
│ Mark Word (64 bits)   │ Class Pointer (32 bits) │
└───────────────────────┴───────────────┘   // 12 bytes total

The compact layout merges the class pointer into unused bits of the Mark Word, resulting in a single 64‑bit header (8 bytes) and a 33 % reduction in header overhead.

┌───────────────────────────────────────┐
│ 64‑bit merged header: Mark Word (31 bits hash),
│ Class Pointer (22 bits), other bits … │
└───────────────────────────────────────┘   // 8 bytes total

How the reduction is achieved

Class Pointer Compression: the 32‑bit pointer is compressed to 22 bits, supporting roughly 4 million distinct classes—far beyond real‑world needs.

Embedding into Mark Word: the compressed class pointer is stored in the unused portion of the Mark Word, eliminating a separate field.

Preserving a 31‑bit hash code to avoid hash‑collision performance regressions.

Compatibility and runtime support

Project Lilliput introduced Object Monitor Tables in JDK 22, decoupling lock metadata from the object header and preserving synchronization semantics.

Before JDK 27 the feature had to be enabled manually: java -XX:+UseCompactObjectHeaders -jar app.jar From JDK 27 onward it is enabled by default; it can be disabled with: java -XX:-UseCompactObjectHeaders -jar app.jar Restrictions:

Do not combine with the deprecated -XX:-UseCompressedClassPointers flag.

ZGC on x64 is still being finalized (G1, Parallel, Shenandoah are fully supported).

The 4‑million class limit does not affect >99.9 % of applications.

Performance measurements

Community measurements show four major gains:

Heap memory reduction : SPECjbb2015 – 22 % less heap; 10 M Point objects – 30 % less allocation, 12 % lower live memory.

CPU usage drop : SPECjbb2015 – 8 % less CPU time; Amazon production services – up to 30 % CPU reduction; high‑concurrency JSON parsing – 10 % faster.

GC pressure relief : SPECjbb2015 – 15 % fewer GC cycles for both G1 and Parallel collectors; shorter, more stable pause times.

Cloud‑native deployment density : smaller container memory footprints allow more instances per host, faster cold starts, and direct cloud‑cost savings.

Amazon’s engineering team back‑ported compact headers to JDK 17/21, ran the feature in hundreds of production services and observed up to 30 % CPU reduction, influencing the decision to ship the feature in JDK 25 and default it in JDK 27. SAP’s SapMachine already defaults to compact headers and runs extensive compatibility tests.

Project Lilliput roadmap

Infrastructure (JDK 22) : Object Monitor Tables introduced.

Experimental (JDK 24, JEP 450) : compact headers available as an experimental feature, manual activation required.

Product (JDK 25, JEP 519) : compact headers integrated as a product feature, still requires -XX:+UseCompactObjectHeaders.

Default (JDK 27, JEP 534) : compact headers become the default layout, no JVM flags needed.

Future : Lilliput 2 aims for a 32‑bit object header.

Technical background

In typical Java applications the object header accounts for more than 20 % of heap memory. For small objects of 32–64 bytes, the 12‑byte header adds roughly 37.5 % overhead. Reducing the header size improves cache locality because more objects fit into CPU L1/L2 caches, decreasing main‑memory accesses.

Usage

Before JDK 27 (e.g., JDK 25/26) enable compact headers manually: java -XX:+UseCompactObjectHeaders -jar app.jar From JDK 27 onward the feature is enabled by default. To revert to the classic layout (e.g., for JNI/Unsafe code that depends on the old layout) use:

java -XX:-UseCompactObjectHeaders -jar app.jar

References

JEP 534: Compact Object Headers by Default – https://openjdk.org/jeps/534 JDK 27 Project Page – https://openjdk.org/projects/jdk/27/ JEP 519: Compact Object Headers –

https://openjdk.org/jeps/519