Garbage Collection Pause

A garbage collection pause is a delay caused by memory reclamation work that interrupts, slows or blocks useful application execution. The pause may stop all application threads, block one event loop, delay allocation, slow worker progress or create tail latency while the runtime traces, moves, frees or compacts objects.

GC pauses matter because they often appear as rare latency spikes. A service can have good median latency and still fail interactive, telemetry, watchdog or control requirements when a pause lands inside the wrong request or timing window.

Pause Measurement

For one collection, define pause duration as:

Over an observation window:

with pauses:

the observed pause fraction is:

This fraction helps capacity review, but the maximum and high-percentile pauses usually matter more for deadlines.

Allocation Pressure

Let allocation rate be:

and effective free heap headroom be:

A simple time-to-pressure screen is:

This is only a rough screen because object lifetime, fragmentation, generation sizing, pinned objects and collector policy determine whether pressure becomes a short collection, long compaction or allocation stall.

Headroom Screen

Suppose effective free heap headroom is:

and burst allocation rate is:

The simple headroom time is:

If a service can receive a retry storm or batch import lasting longer than 6 s, the design needs more than average heap occupancy. It needs bounded queues, allocation limits, spillover behavior, backpressure or admission control before memory pressure turns into long pauses.

Pause Distribution

GC evidence should separate mean pause, percentile pause and maximum observed pause. A release decision based on:

can be misleading if:

The engineering contract should state whether it uses p99, p99.9, maximum observed value or a tested worst case. Interactive services may tolerate occasional moderate pauses. Control, telemetry freshness and watchdog paths may need a hard maximum.

Worked Deadline Screen

Suppose a latency-sensitive path has base response:

queue and scheduler delay:

and p99 GC pause:

The guarded response is:

For a deadline:

the margin is:

If p99.9 GC pause reaches 62 ms, the response becomes 142 ms and the margin becomes -22 ms. The design fails even though p99 appeared barely acceptable.

Stop-The-World Boundary

The report should state which threads stop during the pause. A full stop-the-world collector can delay every request on the process. A concurrent collector may reduce global pause time but still create short synchronization pauses, allocation barriers, CPU competition or memory-bandwidth interference.

For event-loop systems, one blocked allocation path can look like event loop lag. For worker-pool systems, GC can reduce effective worker capacity while queues continue to grow.

Validation Evidence

Useful evidence includes collector type, runtime version, heap size, allocation rate, live-set size, object lifetime distribution, pause histogram, maximum observed pause, p95, p99 and p99.9 latency, allocation stall count, CPU profile, memory pressure, container limit, page-fault count and traces linking pauses to request outcomes.

The workload should include warmup, burst traffic, large payloads, logging volume, retry storms, cache churn and degraded dependencies. A quiet benchmark with a small heap may hide the exact allocation pattern that creates production pauses.

Design Levers

Useful levers include reducing allocation rate, reusing buffers carefully, streaming large payloads, bounding queue size, limiting retries, separating latency-critical work, tuning heap limits, choosing a collector mode that matches the latency objective, avoiding excessive logging allocations and measuring pauses in release tests.

The goal is not always “no garbage collection.” The goal is a runtime and allocation design whose pause distribution fits the engineering margin.

Relationship To Neighbor Terms

Latency is the end-to-end delay seen by work. Garbage collection pause is one contributor to tail latency. Event loop lag can be caused by GC when callbacks cannot run. Timeout budget and deadline miss expose the user-visible failure. Queue backpressure and admission control limit the amount of work that can accumulate while the runtime is paused.