The Young Generation and Old Generation are two major areas of the Java Heap Memory used by the Garbage Collector (GC) to manage objects efficiently. Newly created objects are initially allocated in the Young Generation. Objects that remain alive after multiple garbage collection cycles are promoted to the Old Generation.
Key Points: • Young Generation stores newly created and short-lived objects. • Old Generation stores long-lived objects that survive multiple garbage collections. • Garbage collection in the Young Generation is called Minor GC. • Garbage collection in the Old Generation is called Major GC or Full GC. • Most Java objects die young, which is why the JVM focuses frequent cleanup on the Young Generation.
Why Is Heap Memory Divided?
Studies have shown that most objects created by applications are short-lived.
Examples:
• Method variables • Temporary objects • Request processing objects
Instead of scanning the entire heap repeatedly, the JVM separates memory into generations for better performance.
Heap Structure:
Java Heap | |---- Young Generation | |---- Old Generation
This design improves garbage collection efficiency.
Young Generation
The Young Generation is the area where all newly created objects are allocated.
It is further divided into:
• Eden Space • Survivor Space S0 • Survivor Space S1
Structure:
Young Generation | |---- Eden |---- Survivor S0 |---- Survivor S1
Object Lifecycle:
1. Object created in Eden. 2. Minor GC occurs. 3. Surviving objects move to Survivor Space. 4. Objects surviving multiple GC cycles are promoted to Old Generation.
Characteristics:
• Contains short-lived objects. • Minor GC is usually fast. • Frequent garbage collection occurs.
Example:
String name = "Java";
Employee employee =
new Employee();These newly created objects are initially stored in Eden Space.
Old Generation
The Old Generation stores objects that have survived several Minor GC cycles.
Examples:
• Cached objects • Application-wide configurations • Singleton objects • Long-lived collections
Characteristics:
• Stores long-lived objects. • Garbage collection occurs less frequently. • Major GC is more expensive and slower.
Example:
A singleton configuration object that remains in memory throughout the application's lifetime is likely stored in the Old Generation.
How Objects Move Between Generations
Step 1:
Object created.
Location:
Eden Space
Step 2:
Minor GC runs.
Surviving object moves to:
Survivor Space
Step 3:
Object survives multiple Minor GCs.
Promoted to:
Old Generation
Flow:
Eden | Minor GC | Survivor Space | Multiple Survivals | Old Generation
Garbage Collection Types
1. Minor GC
Targets:
Young Generation
Characteristics:
• Fast • Frequent • Low pause time
2. Major GC / Full GC
Targets:
Old Generation (and sometimes entire heap)
Characteristics:
• Slower • More expensive • Longer pause times
Comparison
Feature Young Generation Old Generation
Purpose New Objects Long-Lived Objects
GC Type Minor GC Major/Full GC
Frequency Frequent Less Frequent
Performance Cost Lower Higher
Object Lifetime Short Long
Memory Area Eden + Survivors Tenured Space
Example: Consider an online shopping application.
Short-Lived Objects:
• HTTP requests • Temporary calculations • Validation objects
Stored in:
Young Generation
Long-Lived Objects:
• Product cache • Application settings • Singleton services
Stored in:
Old Generation
Why Is This Important?
If too many objects are promoted to the Old Generation:
• Heap usage increases. • Major GC becomes more frequent. • Application performance may degrade.
Monitoring tools such as:
• Java Flight Recorder (JFR) • Java Mission Control (JMC) • VisualVM
can help analyze memory behavior.
Interview Tip: A concise interview answer is:
"The Young Generation stores newly created objects and is cleaned frequently using Minor GC. Objects that survive multiple garbage collection cycles are promoted to the Old Generation, which stores long-lived objects. Garbage collection in the Old Generation is less frequent but more expensive, making proper memory management important for application performance."