Garbage Collection in Java: Types, How It Works, and Example

Memory management is an essential aspect of programming, ensuring that resources are utilized efficiently and no memory is wasted. In Java, one of the core features of memory management is Garbage Collection (GC), which automatically handles the process of reclaiming memory occupied by objects that are no longer in use. This automatic memory management allows developers to focus on writing code without worrying about manually deallocating memory, as is required in many other languages like C or C++.

In this blog post, we’ll explore what garbage collection is, how it works in Java, the different types of garbage collectors available, and provide an example to demonstrate the process.

What is Garbage Collection in Java?

In Java, Garbage Collection (GC) is the process of automatically reclaiming memory that is no longer being used by the program. The Java Garbage Collector (GC) is a part of the Java Virtual Machine (JVM) that manages the deallocation of objects in memory. When objects are no longer reachable through any active references, they become eligible for garbage collection. The JVM then removes these objects from memory, freeing up space for new objects.

The heap memory, where Java objects are stored, is automatically cleaned up by the garbage collector. By performing garbage collection, Java helps prevent memory leaks, which occur when memory that is no longer needed isn’t freed properly, ultimately leading to performance issues and application crashes.

How Garbage Collection Works in Java

The process of garbage collection in Java is divided into several phases, and it works as follows:

1. Marking Phase:
   • The garbage collector starts by identifying which objects in the heap are still reachable. These are objects that can still be accessed by the program, either directly or indirectly through references (like from local variables, class fields, etc.).
   • The reachable objects are marked as live objects, while the others (those that are not referenced) are marked as garbage and eligible for collection.
2. Sweeping Phase:
   • After the marking phase, the garbage collector sweeps through the heap to remove all objects that are no longer reachable (unreferenced). These objects are no longer needed and can be safely deleted from memory.
3. Compacting Phase (optional):
   • In some garbage collection algorithms, after sweeping, the heap is compacted. This involves rearranging the objects in memory to reduce fragmentation, ensuring that free memory is contiguous. This helps in optimizing memory allocation for future objects.

The garbage collector runs in the background, but it doesn’t run constantly; it’s triggered based on the JVM’s memory management needs. In most cases, Java developers do not have to manually trigger garbage collection; it’s handled automatically by the JVM.

Types of Garbage Collectors in Java

There are several types of garbage collectors in Java, each designed for different performance goals and use cases. Some of the most common garbage collectors are:

1. Serial Garbage Collector (Single-threaded)

• The Serial Garbage Collector uses a single thread for both minor and major garbage collection cycles. It is the simplest garbage collector and is often used in single-threaded environments or applications with small heaps.
• Use case: Best suited for small applications with low memory consumption, or applications where the application pause time is not critical.

JVM Option: -XX:+UseSerialGC

2. Parallel Garbage Collector (Multi-threaded)

• The Parallel Garbage Collector (also known as the Throughput Collector) uses multiple threads for the garbage collection process, especially for the minor garbage collection cycles. It helps improve performance by utilizing multiple cores of the CPU.
• Use case: Suited for applications that require high throughput, where the focus is on maximizing application performance rather than minimizing pause times.

JVM Option: -XX:+UseParallelGC

3. CMS (Concurrent Mark-Sweep) Garbage Collector

• The CMS Garbage Collector is designed to minimize pause times by performing most of its work concurrently with the application threads. It tries to avoid long pauses by doing the major garbage collection in parallel and concurrently with the application.
• Use case: Ideal for applications where response time is critical, such as web applications or real-time systems.

JVM Option: -XX:+UseConcMarkSweepGC

4. G1 (Garbage First) Garbage Collector

• The G1 Garbage Collector is designed for applications with large heaps and is more predictable than CMS in terms of pause times. It divides the heap into smaller regions and collects garbage incrementally in those regions.
• Use case: Best suited for large-scale applications with large heaps, where low-latency pause times are essential.

JVM Option: -XX:+UseG1GC

5. Z Garbage Collector (ZGC)

• The ZGC is a low-latency garbage collector introduced in Java 11, designed to handle very large heaps with minimal pause times. It is intended for applications that require high performance and low-latency memory management.
• Use case: Best for applications with extremely large heaps (multi-terabyte) and minimal latency requirements.

JVM Option: -XX:+UseZGC

6. Shenandoah Garbage Collector

• Similar to ZGC, Shenandoah is a low-latency garbage collector that aims to reduce GC pause times to a minimum. It is ideal for applications that require predictable low-latency performance.
• Use case: Large applications that need consistent response times and have significant memory requirements.

JVM Option: -XX:+UseShenandoahGC

Example of Garbage Collection in Java

Here’s a simple example to demonstrate how garbage collection works in Java:

public class GarbageCollectionExample {
    
    public static void main(String[] args) {
        // Create objects
        GarbageCollectionExample obj1 = new GarbageCollectionExample();
        GarbageCollectionExample obj2 = new GarbageCollectionExample();
        
        // Make obj1 eligible for garbage collection
        obj1 = null;
        
        // Call garbage collector manually (although it's not necessary)
        System.gc(); // Request JVM to run garbage collection
        
        // obj2 is still reachable, so it won't be collected
        System.out.println("obj2 is still alive: " + (obj2 != null));
    }

    @Override
    protected void finalize() {
        // This method is called just before the object is garbage collected
        System.out.println("Garbage Collection is happening!");
    }
}

In this example:

1. We create two objects, obj1 and obj2.
2. We set obj1 to null, which makes it eligible for garbage collection because no references are left to it.
3. We manually request garbage collection using System.gc(). Note that calling System.gc() is generally not recommended as the JVM handles garbage collection automatically, and the timing is not guaranteed.
4. The finalize() method is overridden to print a message when the object is about to be garbage collected.

Conclusion

Garbage collection in Java is a critical feature that helps manage memory automatically, preventing memory leaks and improving performance. The JVM offers various types of garbage collectors suited for different types of applications, such as the Serial, Parallel, CMS, and G1 collectors. Understanding how garbage collection works and the different types available can help developers make informed decisions about which garbage collector to use based on the specific needs of their applications.

While garbage collection is mostly automatic, it’s essential to understand its concepts and how it impacts your application’s performance. By selecting the right garbage collector for your application and managing memory efficiently, you can ensure your Java applications run smoothly and scale effectively.