---
title: "How does the garbage collector work in Java?"  
description: "How does the garbage collector work in Java?"  
author: "Anubhav Sharma"  
published: 2024-07-18  
updated: 2024-07-19  
canonical: https://www.mindstick.com/forum/160951/how-does-the-garbage-collector-work-in-java  
category: "java"  
tags: ["java", "javac"]  
reading_time: 3 minutes  

---

# How does the garbage collector work in Java?

How does the [garbage collector](https://www.mindstick.com/forum/159018/how-does-rust-manage-memory-safety-without-a-garbage-collector) work in Java? [Explain](https://www.mindstick.com/forum/157854/what-is-system-debugging-explain-some-system-debugging-tools-used-in-modern-computer-systems) different types of garbage collectors available.

## Replies

### Reply by Ravi Vishwakarma

The garbage [collector](https://www.mindstick.com/forum/155585/what-is-garbage-collector) in Java is responsible for automatically managing memory by reclaiming memory occupied by objects that are no longer in use. This process helps in preventing memory leaks and optimizing the use of available memory. Here's an overview of how the garbage collector works in Java:

### Key Concepts

**Automatic Memory Management**:

- Java's garbage collector (GC) automates the process of freeing memory, relieving developers from manually managing memory allocation and deallocation.

**Heap Memory**:

- Objects in Java are allocated in the heap memory. The heap is divided into different generations to optimize the GC process.

**Generations in Heap**:

- **Young Generation**: This is where new objects are allocated and aged. It is further divided into:

   - **Eden Space**: Where new objects are initially allocated.
   - **Survivor Spaces (S0 and S1)**: Where objects that survive garbage collection in the Eden space are moved.

- **Old Generation (Tenured Generation)**: This is where long-lived objects are moved after surviving multiple garbage collection cycles in the young generation.
- **Permanent Generation (Metaspace in Java 8 and later)**: This is where metadata about classes and methods are stored.

**Garbage Collection Phases**:

- **Mark**: The GC identifies which objects are still in use (reachable from the root references).
- **Sweep**: The GC removes objects that are no longer reachable.
- **Compact (optional)**: The GC compacts the memory by moving the live objects together to eliminate fragmentation.

### Types of Garbage Collectors

Java provides different types of garbage collectors, each with its own algorithms and optimizations:

**Serial Garbage Collector**:

- Uses a single thread to perform all garbage collection work. It is suitable for small applications with single-threaded environments.

**Parallel Garbage Collector (Throughput Collector)**:

- Uses multiple threads for garbage collection, aiming to reduce GC pause times and improve application throughput.

**Concurrent Mark-Sweep (CMS) Collector**:

- Performs most of the garbage collection work concurrently with the application threads, aiming to minimize pause times. It is suitable for applications requiring low-latency response times.

**G1 (Garbage First) Collector**:

- Divides the heap into regions and prioritizes the collection of regions that are mostly full of garbage. It aims to provide predictable pause times and is suitable for large heap applications.

## Example -

```java
public class GarbageCollectionExample {
    public static void main(String[] args) {
        // Step 1: Create new objects in the Eden space
        MyObject obj1 = new MyObject();
        MyObject obj2 = new MyObject();

        // Step 2: obj1 becomes unreachable
        obj1 = null;

        // Step 3: Request garbage collection (not guaranteed to run immediately)
        System.gc();

        // Step 4: obj2 is promoted to the old generation after surviving GC cycles
        for (int i = 0; i < 100; i++) {
            System.gc();
        }
    }
}

class MyObject {
    private int[] data = new int[1000];
}
```

## Read more

[**Describe the life cycle of a thread in Java.**](https://www.mindstick.com/forum/160947/describe-the-life-cycle-of-a-thread-in-java)

[**What is the significance of the final keyword when applied to classes, methods, and variables?**](https://www.mindstick.com/forum/160946/what-is-the-significance-of-the-final-keyword-when-applied-to-classes-methods-and-variables)


---

Original Source: https://www.mindstick.com/forum/160951/how-does-the-garbage-collector-work-in-java

Copyright © MindStick Software Pvt. Ltd. This Markdown version is provided for developers, AI systems, and offline reading.