🧹 Garbage Collection (GC) in Java

#developer #resources #software #computerscience

Have you ever wondered who cleans up the objects you stop using in Java?
The answer: The Garbage Collector (GC) — one of Java’s most powerful features that manages memory automatically.

Let’s explore what it is, how it works, and why it’s so important 👇

🧠 What Is Garbage Collection?

Garbage Collection is the process of automatically freeing memory by removing objects that are no longer reachable in your program.

In simpler terms — Java’s GC looks for objects your code no longer uses and deletes them to make space for new ones.

Example:

public class Main {
    public static void main(String[] args) {
        String name = new String("Mohammed");
        name = null; // The old object becomes unreachable
        System.gc(); // Suggests garbage collection
    }
}

Here, the "Mohammed" object becomes garbage when name no longer references it.

🧩 Why Do We Need Garbage Collection?

In languages like C or C++, developers must manually allocate and free memory.
But in Java, the GC automatically handles that for you.

Without GC:

❌ Memory leaks
❌ Dangling pointers
❌ Manual cleanup headaches

With GC:

✅ Automatic memory management
✅ Safer and cleaner programs
✅ Fewer memory-related bugs

In short — GC allows you to focus on logic, not memory management.

⚙️ How Does the Garbage Collector Work?

Java’s memory is divided into two main areas:

Heap → Where objects are created.
Stack → Where references and method calls live.

The GC focuses on the heap.

Here’s a simplified process:

The GC marks all objects that are still reachable.
It identifies objects that are not reachable anymore.
It cleans up (deletes) the unreachable objects.
It may compact memory to make allocation faster.
This process is automatic, but it happens behind the scenes.

🪄 When Does Garbage Collection Happen?

You can suggest GC to run using:

System.gc();

…but remember — this is just a request, not a command.
The JVM decides when to actually perform garbage collection, based on memory pressure and usage.

🔍 How the JVM Knows What to Collect

The GC uses a concept called reachability:

An object is reachable if it can still be accessed through:

A local variable in a method
A static field
Another reachable object

If none of these point to it, the object is unreachable → it becomes garbage.

Example:

class Car {
    String name;
    Car(String name) { this.name = name; }
}

public class Main {
    public static void main(String[] args) {
        Car c1 = new Car("BMW");
        Car c2 = new Car("Audi");
        c1 = null; // BMW object now unreachable
    }
}

✅ The "Audi" object is still reachable through c2.
🗑 The "BMW" object is garbage and will be collected eventually.

🚦 Different Garbage Collectors in Java

Java has multiple GC algorithms (you can choose based on your use case):

Serial GC — best for single-threaded applications.
Parallel GC — uses multiple threads for faster collection.
G1 GC (Garbage First) — default in modern JVMs; balances performance and pause time.
ZGC & Shenandoah — advanced low-latency collectors for large-scale apps.

You can specify which GC to use with JVM flags, for example: