Detailed Explanation of Generational Garbage Collection Mechanism in Java

1. Generational Hypotheses and Design Philosophy

   1. Weak Generational Hypothesis: The vast majority of objects are short-lived, with very brief lifecycles.
   2. Strong Generational Hypothesis: Objects that survive more garbage collection cycles are less likely to become garbage.
   3. Based on these two hypotheses, the JVM divides heap memory into different generations and adopts different collection strategies.

2. Memory Generational Structure
   The heap memory is divided into three main areas:

   1. Young Generation

      • Eden Space: Newly created objects are first allocated here.
      • Survivor Spaces (two): From Survivor and To Survivor, holding objects that survive Minor GC.
      • Default ratio: Eden:From:To = 8:1:1

   2. Old Generation

      • Holds long-lived objects.
      • Large objects may also be directly allocated in the Old Generation.

   3. Metaspace (JDK8+)

      • Replaces the Permanent Generation, storing class metadata information.

3. Object Allocation and Promotion Process

   1. New objects are preferentially allocated in the Eden Space.

   2. When the Eden Space is full, a Minor GC is triggered:
      a) Mark live objects in Eden and the From Survivor space.
      b) Copy the surviving objects to the To Survivor space.
      c) Clear Eden and the From Survivor space.
      d) Swap the roles of the From and To Survivor spaces.

   3. Conditions for object promotion to the Old Generation:

      • Age Threshold: An object survives a certain number (default 15) of Minor GCs while in the Survivor spaces.
      • Large objects go directly to the Old Generation.
      • When the total size of objects of the same age in a Survivor space exceeds half of that Survivor space's capacity, objects with an age greater than or equal to that age are promoted directly.

4. Types of Garbage Collection

   1. Minor GC / Young GC

      • Collects only the Young Generation.
      • Uses the Copying algorithm, resulting in short pause times.
      • Trigger condition: Eden Space is out of memory.

   2. Major GC / Old GC

      • Collects only the Old Generation.
      • Often confused with Full GC, but actually refers specifically to Old Generation collection.

   3. Full GC

      • Collects the entire heap, including Young Generation, Old Generation, Metaspace, etc.
      • Results in longer pause times; frequent occurrences should be avoided.
      • Trigger conditions: Old Generation out of memory, Metaspace out of memory, System.gc() call, etc.

5. Garbage Collection Algorithm Combinations

   1. Young Generation: Copying Algorithm

      • Advantages: No memory fragmentation, high efficiency.
      • Disadvantages: Wastes a portion of memory space.

   2. Old Generation: Mark-Sweep or Mark-Compact Algorithm

      • Mark-Sweep: Generates memory fragmentation but is fast.
      • Mark-Compact: Avoids fragmentation but requires moving objects.

   3. Common Combinations:

      • Serial + Serial Old: Single-threaded, suitable for client applications.
      • Parallel Scavenge + Parallel Old: Throughput prioritized.
      • ParNew + CMS: Low latency, response time prioritized.
      • G1: Regional collection, predictable pause times.

6. Related JVM Parameters

   • -Xms/-Xmx: Heap initial size / maximum size
   • -XX:NewRatio: Ratio of Old Generation to Young Generation
   • -XX:SurvivorRatio: Ratio of Eden to Survivor spaces
   • -XX:MaxTenuringThreshold: Age threshold for object promotion to Old Generation
   • -XX:+PrintGCDetails: Print detailed GC logs

7. Optimization Suggestions

   1. Adjust generational ratios based on application characteristics.
   2. Avoid creating excessively large object arrays.
   3. Set heap size appropriately to avoid frequent Full GC.
   4. Choose a garbage collector suitable for the application scenario.