Memory efficiency has always been a critical concern for Java applications, especially in high-throughput systems, cloud-native workloads, and large in-memory data processing. While developers often focus on heap sizing and garbage collection tuning, a less obvious but equally important factor is object header size.
With the finalisation of Compact Object Headers in Java 25 (JEP 519), the HotSpot JVM now provides a way to significantly reduce heap usage and improve cache efficiency without requiring changes to application code. In this article, we examine the components of an object header and the techniques available in Java 25 for reducing memory usage
1. What Are Object Headers?
In the HotSpot JVM, every object starts with a header that contains essential metadata required by the runtime to manage the object, including a Mark Word used for synchronization, garbage collection state, and identity hash codes, as well as a class pointer that references the object’s class metadata.
Traditionally, on a 64-bit JVM, this header consumed about 96 bits with compressed class pointers, or 128 bits with uncompressed ones. Even tiny objects end up with this fixed overhead, which adds up when you have millions of them, for example, in caches, collections, or heavily object-oriented data structures.
2. The Breakthrough: Compact Object Headers (JEP 519)
Java 25 delivers Compact Object Headers as a full product feature via JEP 519, moving the feature out of the experimental realm introduced in Java 24 (JEP 450). When enabled, Compact Object Headers reduce the HotSpot object header from 96 bits or 128 bits to 64 bits on 64-bit platforms while preserving the required semantics for object identity, class pointers, and garbage collection support.
This reduction is achieved by reorganising the header layout and more aggressively compressing the class pointer using block-based addressing, which refers to addressing in terms of blocks rather than individual bytes. As a result, the class pointer drops from 32 bits to 22 bits, which is sufficient to uniquely address the JVM’s compressed class space when combined with a block size strategy.
Compact Object Headers don’t require application code changes and can reduce the memory footprint significantly for object-heavy workloads.
3. How to Enable Compact Object Headers
In Java 25, we can activate this feature with a JVM option:
-XX:+UseCompactObjectHeaders
Unlike Java 24, we no longer need to unlock experimental features using
-XX:+UnlockExperimentalVMOptions to use it.4. Why Reduced Object Header Size Matters
Object headers represent constant overhead because they exist regardless of how many fields an object contains. For small or short-lived objects, which are common in many business applications, this overhead can dominate the actual data size. By reducing the header size, each object becomes leaner, resulting in several key benefits:
- Lower heap usage: Less memory per object decreases the overall heap footprint.
- Better cache utilization: Smaller objects allow more data to fit into CPU cache lines, reducing cache misses and improving data locality.
- Improved performance: Leaner objects can lead to measurable gains in throughput.
- Lower garbage collection pressure: Reduced memory usage decreases the frequency and impact of GC cycles.
Benchmarks in SPECjbb2015 show that enabling Compact Object Headers can reduce heap usage by up to 22% in some workloads while delivering these performance improvements.
What’s Next?
Although JEP 519 does not make compact headers the default yet, the plan is to mature this optimization and potentially enable it by default in future releases. There’s also ongoing work under Project Lilliput to explore even smaller headers for specialized use cases, though those come with trade-offs and are still in the research phase.
5. Conclusion
In this article, we discussed how a reduced Java object header size allows us to save memory, optimize resource utilization, reduce garbage collection pressure, and enhance the overall performance of our applications.
This article discussed how the Java object header, when reduced in size, can help save memory and significantly improve efficiency.
