Garbage Collection in Java

Garbage collection in Java is an automatic memory management process where the Java Virtual Machine (JVM) automatically deallocates memory used by objects that are no longer reachable or referenced in the program. It helps to prevent memory leaks and ensures efficient memory utilization.

Following is an example to demonstrate garbage collection in Java:

public class GarbageCollectionDemo {
    public static void main(String[] args) {
        // Creating two objects
        MyClass obj1 = new MyClass("Object 1");
        MyClass obj2 = new MyClass("Object 2");

        // Making obj1 eligible for garbage collection
        obj1 = null;

        // Calling garbage collection explicitly (This is not recommended in real-world scenarios)
        System.gc();

        // The objects are still accessible as obj2 is referencing one of them
        System.out.println("obj2: " + obj2.getName()); // Output: obj2: Object 2

        // Making obj2 also eligible for garbage collection
        obj2 = null;

        // Calling garbage collection explicitly (This is not recommended in real-world scenarios)
        System.gc();

        // Even though garbage collection was called, there might be no guarantee it will run immediately.
        // So, the objects may still exist until the JVM decides to perform garbage collection.

        // Attempting to access obj2 will result in a NullPointerException
        // System.out.println("obj2: " + obj2.getName()); // Uncomment this line to see the NullPointerException
    }
}

class MyClass {
    private String name;

    public MyClass(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    protected void finalize() throws Throwable {
        // Finalize method will be called by the garbage collector before the object is reclaimed.
        System.out.println("Object " + name + " is being garbage collected.");
    }
}

In this example above, we have a class called MyClass, which has a constructor and a getName() method to retrieve the name of the object. We create two objects, obj1 and obj2, and then make obj1 eligible for garbage collection by setting it to null. Later, we also make obj2 eligible for garbage collection in the same way.

However, it’s important to note that calling System.gc() explicitly to request garbage collection is generally not recommended in regular Java programs. The JVM is responsible for managing the garbage collection process automatically, and explicit calls to System.gc() can have a performance impact.

Instead, rely on the JVM’s built-in garbage collection mechanisms and let it manage memory on its own. The JVM will run the garbage collector at appropriate intervals or when it determines that it’s necessary based on memory usage and other factors.

Commonly used garbage collectors in Java

The most commonly used garbage collectors in Java are:

• Serial Garbage Collector

This is the simplest garbage collector in Java. It is a single-threaded collector, which means that it only uses one thread to perform garbage collection. This makes it very efficient for small applications with a small memory footprint. However, it can also be inefficient for larger applications, as it can cause long pauses during garbage collection.

• Parallel Garbage Collector

This is a multi-threaded garbage collector that is designed to improve the performance of garbage collection for larger applications. It uses multiple threads to scan through the heap space and perform garbage collection, which can help to reduce the pauses caused by garbage collection.

• Concurrent Mark Sweep (CMS) Garbage Collector

This is a concurrent garbage collector that is designed to minimize the pauses caused by garbage collection. It uses a combination of concurrent and sequential garbage collection techniques to achieve this. CMS is a good choice for applications that require low latency, such as web applications.

• Garbage First (G1) Garbage Collector

This is a newer garbage collector that is designed to offer a good tradeoff between latency and throughput. G1 divides the heap into multiple regions and garbage collects them in a concurrent manner. This helps to minimize the pauses caused by garbage collection, while still achieving good throughput.

• ZGC (Z Garbage Collector)

This is the newest garbage collector in Java. It is designed to achieve very low latency garbage collection. ZGC uses a combination of techniques, such as load barriers and colored pointers, to achieve this. ZGC is a good choice for applications that require very low latency, such as real-time systems.

The best garbage collector to use depends on the specific application. For small applications with a small memory footprint, the Serial Garbage Collector may be a good choice. For larger applications, the Parallel Garbage Collector or CMS Garbage Collector may be a better choice. For applications that require low latency, the G1 Garbage Collector or ZGC Garbage Collector may be a better choice.

Following is a table that summarizes the characteristics of the commonly used garbage collectors in Java:

Frequently Asked Questions

For more detail: https://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html