Garbage Collection

Definition

Garbage Collection is an automatic memory management process used in programming languages to identify objects that are no longer reachable or needed by a program and reclaim the memory they occupy. In the context of Declaring Objects, garbage collection is essential because objects are created dynamically in memory, and when they are no longer in use, the runtime system cleans them up to prevent memory wastage and maintain efficient execution.

In simple terms, garbage collection helps the program manage heap memory without requiring the programmer to manually free objects. This reduces memory leaks, improves safety, and makes object-based programming easier and more reliable.

Main Content

1. Need for Garbage Collection

When objects are created using new or similar mechanisms, they are usually stored in heap memory, which can grow quickly during program execution.
If unused objects are not removed, they continue occupying memory even though the program no longer needs them, leading to inefficient memory use and possible memory exhaustion.

When working with declared objects, programs often create many temporary objects such as:

method-local objects,
objects created inside loops,
objects used for intermediate calculations,
objects that become unnecessary after a task is completed.

For example:

Student s1 = new Student();
s1 = null;

Here, the Student object originally referenced by s1 becomes unreachable after s1 is assigned null. Since no active reference points to that object, it becomes eligible for garbage collection.

Garbage collection is needed because:

it prevents memory from being permanently occupied by unused objects,
it reduces the risk of memory leaks,
it helps programs run longer and more efficiently,
it allows developers to focus on logic rather than low-level memory cleanup.

2. Reachability and Eligibility

An object becomes eligible for garbage collection when it is no longer reachable from any active reference in the program.
Reachability means there is still a chain of valid references from program roots, such as local variables, static variables, or active threads, to the object.

An object may become unreachable in several ways:

its reference variable is reassigned to another object,
its reference is set to null,
the object was created in a temporary scope and the scope ended,
cyclic references exist but no external reference remains.

Example:

class Demo {
    int x = 10;
}

Demo d1 = new Demo();
Demo d2 = d1;
d1 = null;

In this case:

the object is still reachable through d2,
so it is not eligible for garbage collection yet.

But if we do:

d2 = null;

then the object becomes unreachable and eligible for garbage collection.

Important ideas related to eligibility:

Reachable object

: still in use and accessible.

Unreachable object

: no longer accessible from the program.

Garbage

: an object that is unreachable and can be reclaimed.

3. How Garbage Collection Works

The garbage collector periodically checks the heap to find objects that are no longer reachable.
It reclaims the memory used by these unreachable objects and makes that space available for future object creation.

The process generally follows these stages:

Marking

: the collector identifies all reachable objects starting from root references.

Tracing

: it follows references from one object to another to determine the full set of live objects.

Sweeping/Reclaiming

: objects not marked as reachable are removed, and their memory is recovered.

Compacting

: in some implementations, surviving objects are moved together to reduce fragmentation.

A simple memory view:

Heap before collection:
+---------+---------+---------+---------+
| ObjectA | ObjectB | ObjectC | ObjectD |
+---------+---------+---------+---------+
   ^         ^                   ^
  live      live               garbage

After garbage collection:
+---------+---------+---------+
| ObjectA | ObjectB | ObjectD |
+---------+---------+---------+

In this example, ObjectC is not reachable and is removed.

Garbage collection may run:

automatically at runtime,
when memory pressure increases,
when the system detects enough unreachable objects,
at times decided by the runtime environment.

Working / Process

1. Object Creation

A program creates objects dynamically, usually on the heap.
These objects are used by variables, methods, or data structures.
Example: java Car c = new Car();

2. Object Usage and Reference Tracking

The runtime keeps track of references pointing to each object.
As long as at least one active reference exists, the object is considered live.
Example: java Car c1 = new Car(); Car c2 = c1;

3. Detection and Reclamation

The garbage collector identifies unreachable objects.
It frees the memory they occupy and may reorganize memory for efficiency.
Example: java c1 = null; c2 = null; // object becomes eligible for GC

A conceptual flow:

Create object -> Use object -> Lose all references -> Object becomes unreachable -> GC reclaims memory

This process is automatic in languages such as Java, C#, and many managed-runtime environments.

Advantages / Applications

Automatic memory management

The programmer does not need to manually free memory for every object.
This reduces coding complexity and makes development safer.

Prevention of memory leaks

Unused objects are removed when they are no longer reachable.
This helps programs run longer without memory exhaustion.

Improved program reliability

Since memory cleanup is handled by the runtime, there is less risk of common errors such as dangling references or double freeing memory.
It is especially useful in large applications with many dynamic objects.

Useful in object-oriented and dynamic applications

Garbage collection is vital in applications that create many short-lived objects, such as web applications, GUI programs, and server-side systems.
It supports dynamic data structures like linked lists, trees, and graphs.

Efficient use of heap memory

By removing unused objects, the system makes room for new objects.
This improves the overall performance of memory allocation.

Summary

Garbage Collection is automatic memory cleanup for unreachable objects.
An object becomes eligible for garbage collection when no active reference can access it.
It helps manage heap memory efficiently and safely.
Important terms to remember
Reachable object
Unreachable object
Heap memory
Garbage collector