Understanding the `finalize()` Method in Java Garbage Collection

How many times is the finalize method called In Java? Explain to me?

In Java, the finalize() method is a protected method of the java.lang.Object class that can be overridden by a class to perform cleanup operations before an object is garbage collected. However, the use of finalize() is generally discouraged for several reasons, and its behavior can be somewhat unpredictable.

Key Points about finalize():

1. Garbage Collection: The finalize() method is called by the garbage collector when it determines that there are no more references to the object. However, there is no guarantee when or even if the finalize() method will be called. The garbage collector runs on its own schedule, and the timing of garbage collection is not predictable.

2. Multiple Calls: The finalize() method is called only once per object, but if an object is not eligible for garbage collection (for example, if there are still references to it), the finalize() method will not be called at all. If an object is resurrected (i.e., if it creates a reference to itself in its finalize() method), it can prevent the garbage collector from reclaiming it, leading to potential memory leaks.

3. Deprecation: Starting from Java 9, the finalize() method has been deprecated due to its unpredictability and the performance issues it can cause. Instead, Java provides other mechanisms for resource management, such as the try-with-resources statement for managing resources like files and sockets, and the java.lang.ref package for more advanced reference handling.

4. Best Practices: Instead of relying on finalize(), it is recommended to use explicit resource management techniques, such as implementing the AutoCloseable interface and using try-with-resources for automatic resource management.

Example of finalize():

Here is a simple example of how finalize() might be used:

class MyClass {
    @Override
    protected void finalize() throws Throwable {
        try {
            // Cleanup code, e.g., closing resources
            System.out.println("Finalizing MyClass instance");
        } finally {
            super.finalize();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj = null; // Make the object eligible for garbage collection
        System.gc(); // Suggest garbage collection
    }
}

In this example, the finalize() method will be called when the garbage collector decides to collect the MyClass instance, but there is no guarantee when that will happen.

Conclusion:

In summary, the finalize() method is called by the garbage collector when it determines that an object is no longer reachable. However, its use is discouraged, and developers are encouraged to use other resource management techniques. The exact number of times finalize() is called depends on the lifecycle of the object and the behavior of the garbage collector, but it is typically called only once per object if it is called at all.