Great question—let's break this down clearly, since off-heap memory is such a critical tool for performance-sensitive systems like HBase but can feel opaque if you're new to the underlying mechanics.

Short answer: Yes, but not in the way you might think. The JVM doesn’t treat off-heap memory as a "managed" memory pool (like the GC-controlled heap), but it provides standard, supported APIs to allocate and interact with memory outside the GC’s jurisdiction starting from early Java versions.

This means off-heap memory access is a core, standardized capability of the JVM—you don’t need third-party hacks to use it, though many libraries (like Ehcache) wrap these APIs to make them easier to work with.

Here’s the low-level tech that powers off-heap memory in Java:

• java.nio.ByteBuffer (Direct Allocations)
  The most common and accessible standard API for off-heap memory, introduced in Java 1.4. Use ByteBuffer.allocateDirect(int capacity) to create a buffer that lives entirely outside the GC-managed heap. The JVM cleans up this memory eventually via phantom reference finalization, but it’s less predictable than heap GC. Frameworks like HBase and Ehcache rely heavily on direct ByteBuffers for off-heap storage because they balance performance with relative safety.

• sun.misc.Unsafe (Internal API)
  A low-level utility class that lets you directly allocate, read, write, and free off-heap memory with near-native speed. It’s not part of the public Java API (Oracle discourages direct use because it bypasses JVM safety checks), but it’s widely used under the hood by high-performance libraries. In newer Java versions (9+), much of Unsafe’s functionality has been replaced by safer, standard alternatives.

• Foreign Function & Memory API (Java 16+)
  The modern, standardized replacement for Unsafe, finalized in Java 20. This API introduces MemorySegment, MemoryAddress, and related classes to safely allocate, access, and manage off-heap memory without relying on internal APIs. It’s designed to be type-safe, secure, and more predictable than direct Unsafe calls—this is the future of off-heap memory handling in standard Java.

• java.lang.invoke.VarHandle (Java 9+)
  A standard class that enables type-safe, atomic access to off-heap memory addresses, replacing some of Unsafe’s riskiest operations. It’s often used alongside direct ByteBuffers or the Foreign Function API to perform thread-safe reads/writes to off-heap data.

To tie this back to your use case: HBase’s off-heap read path uses these technologies to store frequently accessed data outside the heap, which cuts down on GC pauses and speeds up read operations. Ehcache, similarly, wraps these low-level APIs to provide a user-friendly off-heap caching layer without forcing you to deal with the nitty-gritty of memory management.

内容的提问来源于stack exchange，提问作者Adelin