Garbage Collection

HotSpot's simplest collector: one GC thread, and every collection stops all application threads. The young generation is collected by copying live objects into a survivor space; the old generation by a mark-compact pass. Enable it with -XX:+UseSerialGC.

A stop-the-world pause is an interval where the JVM suspends every application thread so the runtime can do work that needs a stable view of the heap and of thread state — for example scanning thread stacks for references. Application code makes no progress for the duration.

White means not yet reached, gray means reached but its outgoing references not yet scanned, black means reached and fully scanned. When no gray objects remain, tracing is complete: everything reachable is black and every remaining white object is unreachable and can be reclaimed.

G1 tracks how much live data each region holds. For a given pause it collects all young regions plus, in mixed collections, the old regions with the least live data - the most garbage - because evacuation cost scales with live bytes, so those regions give the most free space per millisecond spent.

G1 splits the heap into equal-sized regions (a power of two, 1-32 MB, roughly 2048 of them). Each region is tagged at runtime as eden, survivor, old, or humongous. A generation is the current set of regions with that tag, not a contiguous address range.

The space is split in two. Live objects are copied from the in-use half into the empty half, references are updated to the new addresses, and the source half is then reclaimed entirely - dead objects are never touched. Cost scales with survivors only; the price is holding half the space in reserve.

Every phase is stop-the-world but executed by many GC threads at once, minimising total time spent collecting and maximising the share of time the application runs. The cost: full stops whose length grows with live-set size, and no collection work overlapping the application.

A region-based HotSpot collector that does both marking and compaction (evacuation) concurrently with the running application. Its stop-the-world pauses only scan roots and do bookkeeping, so they scale with the root set, not with heap size or live data. Enabled with -XX:+UseShenandoahGC.

A young collection is triggered when allocation cannot be satisfied from the young space — Eden is full. A full collection happens when the old generation cannot accept what must be promoted or has no room, when the class-metadata area hits its threshold, or when something explicitly requests one; in modern collectors it is mostly a fallback after concurrent work fails to keep up.

A safepoint is a point in a thread's execution where the runtime knows exactly where every object reference that thread holds is located, because the compiler recorded a map for that point. Threads can only be paused there; suspending at an arbitrary instruction would leave references the collector cannot find or update.

ZGC marks, relocates and remaps concurrently with running threads. Only three short root-oriented pauses remain: mark start, mark end, relocate start. Their cost scales with the number of thread roots, not with heap or live-set size, so pauses stay sub-millisecond.

Sweeping in place left free space scattered across free lists, so the old generation fragmented. Eventually a promotion needed a contiguous block bigger than any free chunk even though total free bytes were ample. That triggered a fallback to a single-threaded stop-the-world mark-sweep-compact full collection — a pause of many seconds, the exact thing CMS existed to avoid.

An object is lost when a mutator stores a reference to an unscanned (white) object into an already-scanned (black) object, and then deletes every remaining path to it from unscanned objects. The collector never revisits the black object, finds no other route, and treats the live object as garbage.

A snapshot-at-the-beginning barrier saves the overwritten (old) reference before a store, so anything live when marking began stays marked - producing floating garbage but predictable termination. An incremental-update barrier records the newly stored reference or re-greys the target, marking a more current picture at the cost of rescanning.

A load reference barrier is JIT-inserted code that runs when a reference is loaded from the heap: if the referent lives in a region being evacuated, the barrier resolves or copies it to its new location and writes the corrected reference back. That enforces the to-space invariant — application threads only ever work with up-to-date copies. It replaced the Brooks pointer, an extra header word every access had to indirect through.

-XX:+UseParallelGC selects it. Thread count defaults to the number of available processors up to 8, then grows more slowly above that, and is overridable with -XX:ParallelGCThreads. It was the default on server-class machines through JDK 8; from JDK 9 the region-based G1 collector became the default.

Initial mark (stop-the-world, marks roots), concurrent mark, concurrent preclean and abortable preclean, final remark (stop-the-world, catches what mutation changed), concurrent sweep, concurrent reset. Only initial mark and remark paused the application; young collections were separately stop-the-world. Sweeping reclaimed space in place without compacting.

A young collection is a parallel copying collection: live objects in eden and the active survivor space are copied to the other survivor space or promoted to the old generation. A full collection is a parallel mark, summary and sliding-compaction pass over the entire heap. Both move objects, so free space stays contiguous.

If the JVM does not detect a "server-class" machine — roughly at least two available processors and about 1792 MB of memory — ergonomics fall back to Serial. Container limits count: with container support on, cgroup CPU quota and memory limits feed those checks, so a one-CPU container silently gets Serial.

Four passes in one stop-the-world thread: mark live objects from the roots; compute each live object's new address and store it as a forwarding pointer in its header; walk roots and live objects rewriting every reference to the forwarded address; then slide the objects down to those addresses and restore headers.

Init Mark (stop-the-world: scan roots, arm barriers), Concurrent Mark, Final Mark (stop-the-world: drain marking buffers, choose the collection set, evacuate root-referenced objects), Concurrent Cleanup of empty regions, Concurrent Evacuation, Init Update Refs (brief stop), Concurrent Update References, Final Update Refs (stop-the-world: fix remaining roots, recycle regions).

It lets ZGC collect a small young space frequently instead of marking the whole heap each cycle. That required a new store barrier and remembered sets to track old-to-young references. The payoff: much less CPU and heap headroom for a given allocation rate, and fewer allocation stalls.

Its marking and sweeping ran concurrently with the application, which keeps allocating and promoting the whole time. If the cycle starts when the old generation is already full, there is no space to serve those allocations before it finishes, so the JVM falls back to a long stop-the-world full collection. Starting too early wastes CPU on extra cycles.

Heap occupancy crossing a threshold starts the cycle: initial mark (piggybacked on a young pause), concurrent root-region scan, concurrent mark, a short stop-the-world remark, then cleanup. It produces per-region live-data counts, frees entirely empty regions immediately, and builds the old-region candidate list for mixed collections.

Each region has a remembered set listing where references into it come from, recorded as card-table cards in other regions. Evacuating a region means scanning its remembered set instead of the whole heap. Updates flow from a post-write barrier through dirty-card queues to refinement threads; the cost is memory plus barrier and refinement CPU.

Both mark identically. Mark-sweep then adds dead space to a free list and leaves survivors in place, so the heap fragments. Mark-compact instead slides survivors together into one contiguous block and rewrites every reference to them, ending fragmented-free but paying a relocation plus pointer-fixup pass over live data.

It continuously resizes eden, the survivor spaces and the old generation, and adjusts the tenuring threshold, using measured collection statistics. Goals in priority order: the pause-time goal, then the throughput goal, then minimum footprint. Disable it when you need stable, explicitly-set generation sizes for reproducible behaviour.

For: on one core, extra GC threads only time-slice against the application, and Serial has the smallest footprint, cheapest barriers and fastest startup. Against: pauses are single-threaded and scale with the live set, so if live data grows the service gets long, unhelpable full GCs. Decide by measuring live-set size against the latency budget.

The collector lost the race against allocation: the heap ran out before the concurrent cycle finished. It then finishes the remaining work stop-the-world (degenerated GC), or falls back to a full stop-the-world compaction if that also fails. Fix by giving more heap headroom, starting cycles earlier, adding concurrent GC threads, or reducing allocation rate.