Java automates memory handling through its garbage collection (GC) subsystem, wich identifies and reclaims memory occupied by objects no longer reachable, mitigating leaks and stability issues.

Core Principles of GC

The mechanism hinges on tracing object reference graphs to separate live instances from abandoned ones. Reachable objects remain in use; unreachable ones become eligible for reclamation.

Phases of Collection

• Identification: Traverse references to mark all live objects.
• Disposal: Sweep away unmarked instances, freeing their memory blocks.
• Defragmentation: Compact surviving objects toward one end of the heap to reduce fragmentation.

Variants of JVM Collectors

Different runtime contexts favor distinct collectors:

• Serial Collector: Executes GC in a single thread; suited for simple applications or single-CPU machines.
• Throughput Collector: Leverages multiple threads for concurrent collection; optimized for multi-core systems where high throughput matters.
• Low-Latency Concrurent Mark-Sweep (CMS): Performs marking and sweeping concurrently with application threads to minimize pause times; targets latency-sensitive workloads.
• Garbage-First (G1) Collector: Divides the heap into regions, prioritizing collection based on estimated garbage content; designed for large heaps and server environments.

Serial Collector Mechanics

Runs GC with a solitary thread. Triggering collection can be demonstrated as follows:

package memory.mgmt;

public class SingleThreadGcDemo {
    public static void main(String[] params) {
        for (int idx = 0; idx < 10000; idx++) {
            new byte[1024];
        }
        System.gc();
    }
}

Invoke the JVM with -XX:+UseSerialGC to enforce this collector:

java -XX:+UseSerialGC memory.mgmt.SingleThreadGcDemo

Throughput Collector Mechanics

Utilizes parallel threads during collection phases, improving efficiency on multicore hardware:

package memory.mgmt;

public class ParallelCollectionDemo {
    public static void main(String[] params) {
        for (int count = 0; count < 10000; count++) {
            new String("temp");
        }
        System.gc();
    }
}

Activate with -XX:+UseParallelGC:

java -XX:+UseParallelGC memory.mgmt.ParallelCollectionDemo

CMS Collector Mechanics

Reduces stop-the-world intervals by interleaving mark and sweep with application execution:

package memory.mgmt;

public class ConcurrentMarkSweepDemo {
    public static void main(String[] params) {
        for (int i = 0; i < 10000; i++) {
            new Object();
        }
        System.gc();
    }
}

Enable via -XX:+UseConcMarkSweepGC:

java -XX:+UseConcMarkSweepGC memory.mgmt.ConcurrentMarkSweepDemo

G1 Collector Mechanics

Partitions heap into equally sized regions, collecting those with most waste first:

package memory.mgmt;

public class RegionBasedGcDemo {
    public static void main(String[] params) {
        for (int j = 0; j < 10000; j++) {
            new StringBuilder().append(j);
        }
        System.gc();
    }
}

Select with -XX:+UseG1GC:

java -XX:+UseG1GC memory.mgmt.RegionBasedGcDemo

Tuning GC Behavior

Adjustment parameters shape performance characteristics:

• Heap ceiling (-Xmx): Caps maximum heap size.
• Heap starting size (-Xms): Sets initial heap allocation.
• Young/Old generation ratio (-XX:NewRatio): Balances sizes between generations.
• Eden/Survivor split (-XX:SurvivorRatio): Controls survivor space sizing within young generation.
• Pause time goal (-XX:MaxGCPauseMillis): Targets upper bounds for stop-the-world duration.

Inspecting GC Activity via Logs

Emit detailed logs to diagnose behavior:

java -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:collection.log memory.mgmt.RegionBasedGcDemo

The collection.log file captures timestamps, pause durations, and memory metrics before and after each cycle.