Garbage Collection (GC) in Java is an automatic memory management process that reclaims memory from objects that are no longer in use, preventing memory leaks and optimizing the application’s performance. It works by identifying objects that are unreachable and freeing up their memory to be reused.

How Garbage Collection Works

  1. Marking:
    • The GC identifies which objects are still in use by the application. It starts with the root objects (like active threads, static variables) and traverses through the objects they reference.
    • Objects that are reachable from the root are considered “live,” and those that cannot be reached are “garbage” or unreachable.
  2. Sweeping:
    • Once the marking phase is complete, the garbage collector removes unreachable objects and frees up memory. The memory is now available for allocation to new objects.
  3. Compaction (Optional):
    • After sweeping, there might be fragmentation in memory. Some garbage collectors compact the heap, moving objects together to reduce fragmentation and improve memory utilization.

Key Components of Garbage Collection

  • Heap: The area of memory where objects are stored. The heap is divided into Young Generation and Old Generation:
    • Young Generation: Stores newly created objects. It includes the Eden space and Survivor spaces.
    • Old Generation: Stores long-lived objects that have survived multiple GC cycles.
  • GC Algorithms:
    • Serial GC: A single-threaded garbage collector used for small applications.
    • Parallel GC: Uses multiple threads for garbage collection, improving performance on multi-core systems.
    • CMS (Concurrent Mark-and-Sweep) GC: Aims to minimize application pause time by performing most of the work concurrently with application threads.
    • G1 (Garbage First) GC: Designed for large heaps and minimizes pause times by breaking the heap into regions and collecting them incrementally.

Types of Garbage Collection in Java

  • Minor GC: Occurs in the Young Generation when Eden space is full. It usually takes less time but can still affect performance.
  • Major GC (Full GC): Occurs when the Old Generation is full or when a Minor GC triggers a Full GC. It’s more expensive in terms of time and often causes noticeable pauses.

Automatic vs Manual Memory Management

  • Java’s automatic GC frees developers from manually managing memory, unlike languages like C or C++ where memory management is explicit (using malloc/free).

Triggering Garbage Collection

  • JVM decides when to perform GC based on factors like heap space usage and available memory. You can also force garbage collection (not recommended for normal use) with:

    System.gc();

Conclusion

Garbage Collection in Java helps manage memory automatically by reclaiming space from objects that are no longer in use. It improves efficiency and prevents memory leaks. Understanding how GC works can help developers optimize their applications, especially in performance-critical scenarios.