Garbage Collection

The compiler emits cheap polls — a load from a special polling page — at method returns and at loop back-edges. When a safepoint is requested the VM makes that page unreadable (or flips a thread-local poll word), so the next poll traps into the runtime and parks the thread. Threads in native code are already counted as safe and are blocked when they try to return.

Total stopped time equals the time for every thread to reach a safepoint plus the time the operation runs plus resume. Here roughly 292 ms was time-to-safepoint: one or more threads did not poll promptly. Common causes are long-running counted loops, huge uninterruptible operations, descheduled threads on an oversubscribed host, and page faults on swapped-out stacks.

ZGC puts GC state — marked, remapped, and in the generational design generation and remembered-set bits — into unused bits of every 64-bit heap reference. Barriers interpret and strip the color before use. It requires 64-bit addressing, bounds the address space, and rules out compressed oops.

ZGC selects the pages holding the most garbage as the relocation set, then copies their live objects concurrently. Off-heap forwarding tables map old to new addresses, and load barriers redirect — or perform — each move via compare-and-set. Pages are freed immediately; stale references get remapped lazily.

Every read of a reference field from the heap runs a load barrier. The fast path tests the pointer's color against the current good color; a bad color takes a slow path that marks the object or looks up its new location, then writes the corrected pointer back into the field it was read from — self-healing.

Treat it as unavoidable: staying pinned costs security updates and language features for a collector nobody maintains. Move to the region-based collector (G1) as the default — it compacts as part of normal collection, removing the fragmentation failure mode. Drop CMS-specific flags rather than translating them, set a pause-time goal and heap size, then validate against production-shaped load.

G1 keeps statistics on past pauses and predicts the cost of evacuating candidate regions, then sizes the young generation and the collection set so the predicted pause fits the goal. It is a prediction, not a guarantee: mispredictions, humongous allocation, evacuation failure, and full GCs all overshoot it.

Choose it when the success metric is completion time or cost rather than tail latency, and when CPU is scarce: batch and ETL jobs, CI and build workers, short-lived tasks, and small containers with one or two cores where concurrent GC threads would compete with application threads. Justify with measured GC overhead and end-to-end runtime, not with a preference.

Pauses retain the work that needs global agreement or a stable per-thread view: capturing roots from thread stacks, switching collector phase and barrier state, and finishing marking. Moving the rest off the pause costs throughput through barriers on every reference access, CPU shared with the application, floating garbage, and heap headroom so the concurrent cycle can finish before the heap fills.

You gain GC pauses under a millisecond regardless of heap or live-set size. You pay a barrier cost on reference loads, CPU for concurrent GC threads, extra heap headroom, and the loss of compressed references. The failure mode is allocation stalls, not long pauses — size CPU and heap for that.

Barrier cost scales with reference-store frequency, not heap size. Measure it by comparing collectors with different barrier designs on real traffic, watching application throughput rather than pause charts. Levers: reduce reference writes in hot code, prefer primitive or immutable structures, size regions and heap so cross-region traffic falls, and pick a collector whose barrier profile fits.

Moving buys bump-pointer allocation, no fragmentation, and better locality, paid for with relocation cost proportional to live data, precise reference information, and address instability that native code must tolerate. Non-moving keeps addresses stable and collection cheap per cycle, paid for with free-list allocation and fragmentation that can eventually block large allocations.

Split the fleet by SLO class rather than deciding once. Measure per-service live set, full-GC pause distribution, container RSS, and CPU-seconds per request. Standardize the single-threaded collector as the default for low-SLO and short-lived services, with an explicit, reviewed override for latency-critical ones.

It costs throughput (barriers on reference loads run on every request path), CPU (collector threads run alongside the application), and memory headroom (it must have free regions to evacuate into). Validate with real traffic: compare caller-side p99.9, CPU-seconds per request, RSS, and the absence of degenerated or full collections.