Why Understanding JVM Garbage Collection Algorithms Is Essential for Advanced Java Developers

Overview of Garbage Collection

Garbage Collection (GC) has been a hot research topic since the late 1950s and became central to Java after its 1995 release. Modern JDKs introduce many JEPs related to GC, such as G1 (JEP‑248), ZGC (JEP‑333), and Shenandoah (JEP‑189).

Core Concepts

GC Definition

GC treats unreachable memory as "garbage" and performs two tasks: (1) identify garbage objects and separate them from live ones, and (2) reclaim their memory for reuse.

GC Families

Two main families exist: reachability‑analysis (tracing) collectors and reference‑counting collectors, often combined in modern implementations.

Reachability Analysis

Starting from GC roots (stack locals, static fields, constant pool, JNI references), the collector traverses object graphs; objects not reachable are reclaimed.

Reference Counting

Each object carries a counter incremented/decremented on reference changes; when the count reaches zero, the object is immediately reclaimed. This method suffers from cyclic references and high overhead.

Garbage Collection Algorithms

Basic Algorithms

Mark‑Sweep: mark live objects, then sweep away unmarked ones.

Mark‑Compact: after marking, relocate live objects to eliminate fragmentation.

Mark‑Copy: copy live objects to a new region, leaving the old region free.

Generational GC

Based on the hypothesis that most objects die young, the heap is divided into young and old generations. Minor GC collects the young generation frequently, while major GC handles the old generation less often.

Incremental GC

Reduces stop‑the‑world pauses by interleaving GC work with application execution, using incremental update or incremental copying techniques.

Concurrent GC

Performs marking, relocation, and remapping concurrently with the application, relying heavily on read/write barriers to avoid missed references.

Read/Write Barriers

Barriers intercept reads or writes to object references during concurrent marking, ensuring that newly created or deleted references are correctly accounted for.

void example(Foo foo) {    
    Bar bar = foo.bar; // read barrier
    bar.otherObj = makeOtherValue(); // write barrier
}

Write barriers record old references from old to young generations, enabling correct handling of cross‑generation pointers.

write_barrier(obj, field, new_obj){
    if(obj.old == TRUE && new_obj.young == TRUE && obj.remembered == FALSE){
        remembered_sets[rs_index] = obj;
        rs_index++;
        obj.remembered = TRUE;
    }
    *field = new_obj;
}

Algorithm Improvements

Various refinements address fragmentation, pause time, and space utilization, such as SATB (Snapshot‑At‑The‑Beginning) for incremental marking, and specialized barriers used by G1, Shenandoah, ZGC, and CMS.

Further Reading

Relevant papers: Boost's shared_ptr performance, Dijkstra’s tri‑color marking, generational scavenging, ImmixGC, non‑recursive copying, and others.