Chronicle Map低GC特性解析及基本类型键支持问询

Great questions—let’s break these down clearly, since these are exactly the kinds of details that matter for low-latency systems.

What does "supports ultra-low garbage collection" mean? #

You’re spot on with your intuition: this phrase absolutely refers to minimizing heap memory object allocations to avoid triggering unnecessary garbage collection. For latency-sensitive applications, even minor GC pauses can be catastrophic, so Chronicle Map is built to eliminate these as much as possible.

Here’s how it delivers on that promise:

• Off-heap storage: Most of the map’s data lives outside the JVM’s heap memory. That means the key-value entries you store don’t contribute to heap pressure, so the GC never has to process them.
• No unnecessary autoboxing: Unlike standard JDK maps (like HashMap<Long, Entity>) that force you to use wrapper objects (e.g., Long instead of long), Chronicle Map handles primitive types directly. This cuts out the heap allocations from creating wrapper objects every time you access the map.
• Object reuse: It reuses internal buffers and objects instead of allocating new ones for each operation—similar to the object pooling patterns you mentioned for low-latency systems.

Can Chronicle Map use primitive types as keys? #

Absolutely—this is a core feature designed specifically for low-latency use cases, and it avoids the autoboxing overhead you’d get with libraries like Trove (which, while good, still stores data on-heap).

Technical reasons this works: #

• Raw memory layout: Chronicle Map stores data in off-heap memory using a compact, primitive-friendly layout. For a primitive key like long, it writes the 8-byte raw binary value directly to memory—no wrapper objects, no serialization of heap-based instances.
• Primitive-optimized access: When you do lookups, inserts, or updates, the map operates directly on the primitive value without converting it to an object. This speeds up operations and eliminates temporary heap allocations that would trigger GC.
• No heap dependency: Unlike Trove’s primitive-based maps (which live on the heap and still contribute to GC), Chronicle Map’s off-heap storage takes the entire dataset out of the JVM’s GC scope entirely.

As a quick example, creating a Chronicle Map with a long key might look like this:

ChronicleMap<Long, Entity> longKeyMap = ChronicleMapBuilder.of(long.class, Entity.class)
    .averageKey(1000L)
    .entries(1_000_000)
    .build();

This code creates a map that works directly with long primitives for keys, no Long wrappers required.

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