Java: Memory Management & Garbage Collection

Memory Lifecycle

Object Allocation

Employee employee = new Employee();
Order order = new Order();

Object Reachability

Employee employee = new Employee(); 
employee.setName("John"); 

Eligible for Garbage Collection

Employee employee = new Employee(); 
employee = null; 

Heap Memory Organization

Young Generation

Eden Space

Customer customer = new Customer(); 
Product product = new Product(); 

Survivor Spaces (S0 and S1)

Object Aging

Every time an object survives a Minor Garbage Collection, its age increases.

The JVM tracks this age internally to determine whether an object should remain in the Young Generation or be promoted to the Old Generation. For example:

- New object → Age 0
- Survives first Minor GC → Age 1
- Survives second Minor GC → Age 2


Continues surviving until the promotion threshold is reached

Old Generation

Large Object Allocation

Although most objects are allocated in the Young Generation, very large objects may be allocated directly in the Old Generation.

This avoids repeatedly copying large objects between memory regions during multiple Minor Garbage Collection cycles.

Whether this optimization is used depends on the JVM implementation and the selected garbage collector.

Metaspace

Minor, Major and Full Garbage Collection

Minor Garbage Collection

Major Garbage Collection

Full Garbage Collection

Stop-The-World (STW)

Garbage Collection Process

1. Mark Phase

GC Root → Employee → Department → Manager

2. Sweep Phase

Reachable Objects: ✔ Employee ✔ Department ✔ Manager 
Unreachable Objects: ✘ Order ✘ Customer ✘ Product 

3. Compact Phase

Do All Garbage Collectors Follow This Process?

The Mark → Sweep → Compact model provides a simple way to understand garbage collection, but modern JVM garbage collectors often use more sophisticated techniques.

For example, some collectors copy live objects instead of sweeping memory, while others perform parts of the collection concurrently with application threads to reduce pause times.

Regardless of the implementation, every garbage collector must ultimately:

- Identify reachable objects.
- Reclaim memory occupied by unreachable objects.
- Keep the heap in a state that allows efficient future allocations.

Circular References

class Employee {
    Department department;
}

class Department {
    Employee manager;
}

Employee ─────► Department
    ▲              │
    └──────────────┘

(No path from any GC Root)

GC Roots

Local Variables

public void process() {
    Employee employee = new Employee();
    employee.setName("John");
}

Static Variables

public class Cache {
    private static final Map DATA = new HashMap<>();
}

Active Threads

Thread thread = new Thread(() -> {
    Employee employee = new Employee();
    System.out.println(employee);
});

thread.start();

JNI References

Reference Types

Strong References

Employee employee = new Employee(); 

Soft References

SoftReference reference =
        new SoftReference<>(new Employee());
Employee employee = reference.get(); // Returns null if GC reclaimed it

Weak References

WeakReference reference =
        new WeakReference<>(new Employee());
Employee employee = reference.get();

Phantom References

ReferenceQueue queue = new ReferenceQueue<>();
PhantomReference reference =
        new PhantomReference<>(
                new Employee(),
                queue
        );

finalize() and Cleaner API

class Employee {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("Cleaning up");
    }
}

class DatabaseConnection implements AutoCloseable {
    public void query() {
        System.out.println("Executing query...");
    }
    @Override
    public void close() {
        System.out.println("Connection closed.");
    }
}

public class Main {
    public static void main(String[] args) {
        try (DatabaseConnection connection = new DatabaseConnection()) {
            connection.query();
        }
    }
}

Common Memory Problems

Memory Leak

List cache = new ArrayList<>();

public void addEmployee(Employee employee) {
    cache.add(employee);
}

OutOfMemoryError

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 

java.lang.OutOfMemoryError: Metaspace 

java.lang.OutOfMemoryError: GC overhead limit exceeded 

StackOverflowError

public void print() {
    print();
}

Exception in thread "main" java.lang.StackOverflowError 

Monitoring Memory

jps

jps 

jstat

jstat -gc <pid> 

jmap

jmap -dump:live,file=heap.hprof <pid> 

jcmd

jcmd <pid> GC.heap_info 

jstack

jstack <pid> 

VisualVM and JConsole

Final Notes