28.5. Garbage Collection (GC)

Automatic memory management in Java.

Garbage Collection (GC) in Java refers to the automatic process that the Java Virtual Machine (JVM) uses to manage memory. Instead of programmers manually managing memory allocation and deallocation, Java provides an automated system that identifies and removes objects that are no longer needed, freeing up resources and preventing memory leaks.

Think of garbage collection like a cleaning crew in an office building. As people leave the office (objects are no longer needed), the cleaning crew (the GC) comes in to remove the debris (unused memory) so that the office can be used again efficiently.

• Young Generation • Old Generation • Permanent Generation (before Java 8) / MetaSpace (Java 8+)

Garbage Collection in Java is organized into different generations to optimize performance. The Young Generation is where new objects are allocated, and if they survive long enough, they are promoted to the Old Generation. Before Java 8, the Permanent Generation existed for class metadata, but in Java 8 and later, this was replaced by MetaSpace, which uses native memory instead of heap memory for class metadata.

You can think of the Young Generation as a nursery where newborns are cared for. If a child (object) grows and proves to be useful, they are moved to a school (Old Generation) where they continue to receive education rather than being discarded. The Permanent Generation is like a library of all the books we've read and referenced, but in newer systems, we keep those books on a bookshelf outside the nursery to save space.

• Serial GC: For small applications; single-threaded. • Parallel GC: Multi-threaded for both Young and Old generations. • CMS (Concurrent Mark Sweep): Minimizes pause time. • G1 (Garbage First): Splits heap into regions; balanced GC. • ZGC, Shenandoah (Java 11+): Low-latency, scalable GCs.

There are various algorithms that the JVM employs for Garbage Collection, each designed for different scenarios. For small applications, the Serial GC works well, operating on a single thread. The Parallel GC uses multiple threads and is suited for larger applications. Concurrent Mark Sweep (CMS) aims to minimize the time the application is paused while garbage collection occurs. The G1 garbage collector manages memory in regions, optimizing for both speed and efficiency. Lastly, newer GCs like ZGC and Shenandoah focus on low-latency and scalability.

Consider a restaurant with different dining styles. The Serial GC is like a small diner where one chef (thread) handles all the orders alone, while the Parallel GC resembles a busy restaurant with multiple chefs working on various orders simultaneously. CMS is like a restaurant that tries to serve customers while cleaning up their tables at the same time; it minimizes wait times. G1 is comparable to a buffet where food is replenished in different sections, and ZGC and Shenandoah are like modern restaurants that cater to large crowds efficiently without long waits.

1. Mark
2. Sweep
3. Compact
4. Evacuate (in G1)

The process of Garbage Collection involves several key phases. First, during the 'Mark' phase, the collector identifies which objects are still in use. Next comes the 'Sweep' phase, where any objects that are no longer marked are removed from memory. The 'Compact' phase reorganizes the remaining objects to make the memory cleaner and more efficient. If using G1 GC, the additional 'Evacuate' phase will move live objects to new memory regions to avoid fragmentation.

Imagine cleaning a crowded room. First, you mark items that people still want to keep (Mark phase). Next, you remove items that are not marked (Sweep phase). Afterwards, you tidy up the space, placing items neatly on shelves (Compact phase). If the room has many people, you might even create separate areas for groups to sit without bumping into each other (Evacuate phase), making everyone more comfortable.

--