Introduction to JVM Garbage Collection

Java is a garbage-collected language, so you don't have to directly manage the memory. One of Java’s best offerings is the Garbage Collection (GC) — with GC, developers need not deallocate memory as they would have done in C/C++.

JVM garbage collection refers to the process wherein the JVM automatically collects unwanted objects that are no longer being used by our application so that their resources can be reclaimed and reused.

It’s VERY important for Java developers to understand how Garbage Collection works, particularly when developing high-performance, scalable applications.

Why Garbage Collection is Needed

When a Java program runs:

• Objects are created dynamically using new

• These objects occupy memory in the Heap

• Some objects become unreachable after use

• If unused objects are not removed, memory gets exhausted

Without Garbage Collection:

• Applications may crash due to OutOfMemoryError

• Memory leaks may occur

• Performance degrades significantly

JVM Garbage Collection automatically reclaims memory, making Java safer and more developer-friendly.

Memory Areas Involved in Garbage Collection

Garbage Collection mainly works on the Heap Memory, which is divided into generations:

1. Young Generation

• Newly created objects are stored here

• Divided into:
• Eden Space

• Survivor Space (S0 & S1)

• Minor Garbage Collection happens here

2. Old Generation (Tenured Generation)

• Objects that survive multiple GC cycles are moved here

• Major Garbage Collection happens here

3. Metaspace (Java 8+)

• Stores class metadata

• Not part of the heap but still managed by the JVM

How JVM Identifies Garbage Objects

The JVM does not delete objects randomly. It follows a systematic approach using reachability analysis.

Reachable Objects

Objects are considered alive if they are:

• Referenced by local variables

• Referenced by static variables

• Referenced by active threads

• Part of JNI references

Unreachable Objects

If an object has no reference path from any GC root, it becomes eligible for garbage collection.

Important:

Garbage Collection removes unreachable objects, not unused variables.

Types of Garbage Collection in JVM

1. Minor Garbage Collection

• Occurs in the Young Generation

• Fast and frequent

• Cleans Eden and Survivor spaces

2. Major Garbage Collection

• Occurs in Old Generation

• Slower than Minor GC

• More expensive in terms of performance

3. Full Garbage Collection

• Cleans entire heap (Young + Old)

• Pauses application threads (Stop-The-World)

• Should be minimized in production systems

Garbage Collection Algorithms

1. Mark and Sweep Algorithm

• Marks reachable objects

• Sweeps unreachable objects

• Leaves memory fragmentation

2. Copying Algorithm

• Used in the Young Generation

• Copies live objects to survivor space

• Faster and avoids fragmentation

3. Mark Compact Algorithm

• Mark's live objects

• Compacts memory after deletion

• Used in the Old Generation

Popular Garbage Collectors in JVM

1. Serial Garbage Collector

• Single-threaded

• Best for small applications

• Causes long pauses

2. Parallel Garbage Collector

• Multi-threaded

• Improves throughput

• Used in many server applications

3. CMS (Concurrent Mark Sweep)

• Minimizes pause time

• Runs concurrently with the application

• Deprecated in recent Java versions

4. G1 Garbage Collector

• Default from Java 9+

• Divides the heap into regions

• Balances throughput and latency

5. ZGC and Shenandoah

• Ultra-low pause collectors

• Suitable for large heap applications

Used in modern cloud-based systems

Stop-The-World (STW) Concept

During Garbage Collection:

• JVM pauses all application threads

• GC threads perform cleanup

• Application resumes after GC

This pause is known as Stop-The-World.

Excessive STW pauses can cause:

• Application lag

• Poor user experience

• Performance bottlenecks

finalize() Method and Garbage Collection

Java provides the finalize() method:

protected void finalize() throws Throwable {

    // cleanup code

}

However:

• Execution is not guaranteed

• Deprecated in Java 9+

• Not recommended for resource management

Use try-with-resources instead.

Requesting Garbage Collection

Java provides:

System.gc();

Runtime.getRuntime().gc();

These methods only request GC.

The JVM may ignore the request.

Common Garbage Collection Problems

1. Memory Leaks

• Objects unintentionally referenced

• GC cannot reclaim them

2. Frequent Full GC

• Poor heap configuration

• Large object allocation

3. OutOfMemoryError

• Heap space exhausted

• Metaspace overflow

Best Practices for Efficient Garbage Collection

✔ Reuse objects when possible

✔ Avoid unnecessary object creation

✔ Use proper data structures

✔ Choose the right GC algorithm

✔ Monitor GC logs in production

✔ Tune heap size (-Xms, -Xmx)

Garbage Collection vs Manual Memory Management

Feature

Java GC

Manual (C/C++)

Memory Safety

High

Low

Developer Effort

Low

High

Performance Control

Medium

High

Error Risk

Low

High

Real-World Importance of JVM Garbage Collection

Garbage Collection plays a critical role in:

• Spring Boot applications

• Microservices

• Enterprise systems

• Cloud-native applications

• High-load backend servers

A strong understanding of JVM Garbage Collection helps developers:

• Optimize performance

• Prevent memory leaks

• Handle production issues confidently

Conclusion

JVM Garbage Collection is one of the core pillars of Java’s reliability and performance. While it works automatically, understanding how it functions internally is essential for building efficient, scalable Java applications.

From memory regions and GC algorithms to modern collectors like G1 and ZGC, mastering Garbage Collection gives Java developers a strong edge in real-world projects and interviews.

Do visit our channel to learn More: SevenMentor

Author:-

Srushti Kulkarni