🧠 Memory Management & Garbage Collection in Java

This guide explains how Java manages memory using Stack and Heap, how objects and references work, and how the JVM performs Garbage Collection (GC) to free unused objects.

Table of Contents

1. Stack vs Heap
2. Stack Memory
3. Heap Memory
4. String Pool
5. Memory Allocation Example
6. Object Reachability & GC
7. Garbage Collection Algorithms
8. Young Generation vs Old Generation
9. GC Types
10. Important Concepts

1. Stack vs Heap

Java memory is divided into two main regions:

2. Stack Memory

Stack stores:

• Method call frames (scope)
• Local variables
• Primitive values (int, double, boolean, etc.)
• References to objects (the reference itself, not the object)

Key Behaviors:

✅ LIFO (Last In, First Out) → Variables exist only within their scope

✅ Automatic cleanup → When a method ends, its stack frame is popped and local variables are removed

⚠️ StackOverflowError → Occurs if stack becomes full (common in infinite recursion)

Example:

void myMethod() {
    int x = 10;           // Stack: primitive stored here
    Person p = new Person();  // Stack: reference stored here
}
// When myMethod() ends → stack frame is popped → x & p reference removed

3. Heap Memory

Heap stores:

• Objects created using new keyword
• Arrays
• String pool (String interned values)

Key Characteristics:

✅ Shared across threads → All threads can access heap objects

✅ Garbage collected → Objects freed when no longer referenced

⚠️ OutOfMemoryError → Occurs if heap becomes full

Example:

Person p = new Person();  // Reference 'p' in stack, object in heap
String s = "Hello";       // Literal "Hello" in String pool (heap)

4. String Pool

String literals are stored in a special area called the String Constant Pool (inside heap).

String s1 = "Memory";      // Created in String pool
String s2 = "Memory";      // Points to SAME object in pool
String s3 = new String("Memory");  // NEW object in heap (not in pool)

System.out.println(s1 == s2);  // true (same reference)
System.out.println(s1 == s3);  // false (different objects)

5. Memory Allocation Example

Code:

int primitiveVar = 10;
Person personObj = new Person();
String stringLiteral = "Memory";
MemoryManagement memObj = new MemoryManagement();
memObj.memoryManagementTest(personObj);

UML Class Diagram:

Memory Layout Diagram:

PlantUML Generated Diagram:

What Happens in Memory:

When memoryManagementTest() ends:

• Its local variables’ references are removed from stack
• Heap objects may become unreferenced
• Garbage Collector later cleans up unreachable objects

6. Object Reachability & GC

When Does an Object Become Garbage Collectable?

An object is eligible for garbage collection when it becomes unreachable from GC roots.

Common Ways Objects Become Unreachable:

✅ Assigning to null

Person obj = new Person();
obj = null;  // Object becomes unreachable

✅ Reassignment

Person obj1 = new Person();
Person obj2 = new Person();
obj1 = obj2;  // Old obj1 becomes unreachable (eligible for GC)

✅ Method scope ends

void test() {
    Person obj = new Person();
}  // When test() ends → reference removed → object may become unreachable

7. Garbage Collection Algorithms

Mark → Sweep → Compact

The JVM performs garbage collection in three main steps:

Step 1: Mark

• Identifies all reachable objects from GC Roots
• Marks them as “live”

Step 2: Sweep

• Deallocates unmarked (unreachable) objects
• Frees heap memory

Step 3: Compaction

• Moves live objects together to reduce fragmentation
• Creates contiguous free space

GC Roots (What Keeps Objects Alive):

Objects are considered alive if reachable from:

• Local variables in active threads
• Static variables
• Class references
• Thread objects

8. Young Generation vs Old Generation

Heap Structure:

The JVM heap is divided into generations:

┌─────────────────────────────────┐
│         Young Generation        │
├──────────────┬──────────────────┤
│   Eden       │  Survivor (S0,S1)│
└──────────────┴──────────────────┘
         ↓ (promotion)
┌──────────────────────────────────┐
│      Old / Tenured Generation    │
└──────────────────────────────────┘
         
Metaspace (Non-Heap) - Class metadata

Minor GC (Young Generation):

✅ Runs frequently and quickly

✅ Cleans up short-lived objects in Eden space

✅ Moves surviving objects between Survivor spaces (S0 ↔ S1)

✅ Tracks object age (how many GC cycles survived)

Promotion to Old Generation:

When an object’s age exceeds threshold (typically 8):

• Object promoted from Young → Old generation
• Reduces Young generation size

Major/Full GC (Old Generation):

✅ Runs less frequently but heavier cleanup

✅ Higher pause time (application stops)

✅ Cleans up old long-lived objects

Metaspace:

✅ Stores class metadata and static information

✅ Not part of heap (non-heap memory)

✅ Replaced PermGen in Java 8+

9. GC Types

Different garbage collectors with different trade-offs:

Serial GC

• Single-threaded
• Stop-the-world pauses
• Best for: Small applications, limited CPU

Parallel GC (Default in Java 8)

• Multiple GC threads
• Improved throughput
• Best for: Multi-core systems, server applications

CMS (Concurrent Mark Sweep)

• Reduced stop-the-world time
• Attempts concurrent work with application
• Not fully pause-free
• Best for: Low-latency applications

G1 GC (Garbage First)

• Balances throughput and latency
• Includes automatic compaction
• Aims to limit pause time
• Best for: Large heaps, modern systems

10. Important Concepts

Stop-The-World (STW)

Many GC phases pause application threads:

• Serial GC pauses more
• G1 GC tries to limit pause time
• Longer pauses = noticeable application lag

Java Memory Leaks

Even with automatic GC, leaks can occur when:

• References unintentionally kept alive
• Static maps growing unbounded
• Event listeners not removed
• Thread-local variables not cleaned up

Definition: A memory leak is when an object is no longer needed but remains reachable, preventing GC from freeing it.

System.gc() is Optional

System.gc();  // Just a SUGGESTION, not a command

• JVM may or may not run GC
• GC timing depends on memory pressure and implementation
• Rely on JVM to manage GC automatically

Weak vs Soft References

Strong Reference (Default)

Person p = new Person();  // GC won't delete while reachable

Weak Reference

WeakReference<Person> wp = new WeakReference<>(new Person());
// GC can collect immediately during next GC cycle

Soft Reference

SoftReference<Person> sp = new SoftReference<>(new Person());
// GC collects only when memory is desperately needed (cache scenarios)

Quick Summary & Revision