Finalize use in java

final, finally and finalize in Java

This is an important question concerning the interview point of view.

final (lowercase) is a reserved keyword in java. We can’t use it as an identifier, as it is reserved. We can use this keyword with variables, methods, and also with classes. The final keyword in java has a different meaning depending upon whether it is applied to a variable, class, or method.

final with Variables: The value of the variable cannot be changed once initialized.

Java

If we declare any variable as final, we can’t modify its contents since it is final, and if we modify it then we get Compile Time Error.

final with Class: The class cannot be subclassed. Whenever we declare any class as final, it means that we can’t extend that class or that class can’t be extended, or we can’t make a subclass of that class.

Java

final with Method: The method cannot be overridden by a subclass. Whenever we declare any method as final, then it means that we can’t override that method.

Java

Note : If a class is declared as final as by default all of the methods present in that class are automatically final, but variables are not.

Java

Just as final is a reserved keyword, so in the same way finally is also a reserved keyword in java i.e, we can’t use it as an identifier. The finally keyword is used in association with a try/catch block and guarantees that a section of code will be executed, even if an exception is thrown. The final block will be executed after the try and catch blocks, but before control transfers back to its origin. finally is executed even if try block has return statement.

Java

inside A A's finally Exception caught inside B B's finally

There are various cases when finally can be used. There are discussed below:

Case 1: Exceptions do not occur in the program

Java

In try block Executes whether exception occurs or not

Here the above exception does not occur but still, finally, the block executes since finally is meant to execute whether an exception occurs or not. The flow of the Above Program: First it starts from the main method and then goes to try block and in the try, since no exception occurs, the flow doesn’t go to catch block hence flow goes directly from try to finally block.

Case 2: Exception occurs and corresponding catch block matches

Java

In try block In catch block Dividing by zero but caught Executes whether an exception occurs or not

Here, the above exception occurs, and the corresponding catch block is found but still, finally, the block executes since finally is meant to execute whether an exception occurs or not or whether the corresponding catch block is found or not. The flow of the Above Program: First, starts from the main method and then goes to try block, and in the try, an Arithmetic exception occurs, and the corresponding catch block is also available, so flow goes to catch block. After that flow doesn’t go to try block again since once an exception occurs in try block then flow doesn’t come back again to try block. After that finally, execute since finally is meant to execute whether an exception occurs or not or whether a corresponding catch block is found or not.

Case 3: Exception occurs and the corresponding catch block is not found/match

Java

In try block Executes whether an exception occurs or not Exception in thread "main":java.lang.ArithmeticException: / by zero followed by stack trace.

Here above exception occurs and the corresponding catch block is not found/matched but still finally block executes since finally is meant to execute whether an exception occurs or not or whether the corresponding catch block is found/matched or not. The flow of the Above Program: First starts from the main method and then goes to try block and in try an Arithmetic exception occurs, and the corresponding catch block is not available, so flow doesn’t go to catch block. After that flow doesn’t go to try block again since once an exception occurs in try block then flow doesn’t come back again to try block. After that finally, execute since finally is meant to execute whether an exception occurs or not or whether the corresponding catch block is found/matches or not.

Case 4: finally block doesn’t get execute irrespective of the exception that occurs

Java

Here in the above program, finally, the block doesn’t execute. There is only one situation where finally block won’t be executed when we are using System.exit(0) method. When we are using System.exit(0) then JVM itself shutdown, hence in this case finally block won’t be executed. Here, the number within the parenthesis is known as the status code. Instead of zero, we can take any integer value where zero means normal termination, and non-zero means abnormal termination. Whether it is zero or non-zero, there is no change in the result and the effect is the same with respect to the program.

Application of finally block: So basically the use of finally block is resource deallocation. This means all the resources such as Network Connections, and Database Connections, which we opened in the try block is needed to be closed so that we won’t lose our resources as opened. So those resources are needed to be closed in the final block.

Java

Entered try statement PrintWriter not open

Note: The finally block is a key tool for preventing resource leaks. When closing a file or otherwise recovering resources, place the code in a finally block to ensure that resource is always recovered.

How jdk 1.7 makes usage of the final block optional?

Until jdk 1.6 finally block is like a hero i.e, it is recommended to use it for resource deallocation but from jdk 1.7 onwards finally, the block is now optional (however you can use it). Since the resources which we opened in the try block will automatically get deallocated/closed when the flow of the program reaches the end of the try block. This concept of automatic resource deallocation without using the final block is known as the try-with-resources statement.

Finalize method

It is a method that the Garbage Collector always calls just before the deletion/destroying of the object which is eligible for Garbage Collection, so as to perform clean-up activity. Clean-up activity means closing the resources associated with that object like Database Connection, Network Connection, or we can say resource de-allocation. Remember, it is not a reserved keyword. Once the finalized method completes immediately Garbage Collector destroys that object. finalize method is present in the Object class and its syntax is:

protected void finalize throws Throwable<>

Since the Object class contains the finalize method, hence finalize method is available for every Java class since Object is the superclass of all Java classes. Since it is available for every java class hence Garbage Collector can call finalize method on any Java object Now, the finalize method which is present in the Object class, has an empty implementation, in our class clean-up activities are there, then we have to override this method to define our own clean-up activities. Cases related to finalizing method:

Case 1: The object which is eligible for Garbage Collection, that object’s corresponding class finalize method is going to be executed

Источник

Java finalize() – Why We Should Not Use It?

The finalize() method in Java is called by garbage collector thread before reclaiming the memory allocated to the object. It is considered as a destructor in Java – though It is not similar to what we have in C/C++.

Let’s learn when to use finalize() in Java – and why we should avoid using it, if possible.

The JEP-421 (Java 18) has marked the finalization deprecated. It will be removed in a future release. The use of Cleaners is recommended.

It is called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the finalize() method to dispose of system resources or to perform other cleanups.

Notice that finalize() is the deprecated method.

@Deprecated(since="9") protected void finalize() throws Throwable

A general syntax to override finalize() method is given below.

public class MyClass < //Other fields and methods //. @Override protected void finalize() throws Throwable < try < //release resources here >catch(Throwable t) < throw t; >finally < super.finalize(); >> >

2. The finalize() Execution is Not Guaranteed

Let’s prove it using a program. I have written a simple Java runnable with one print statement in each block i.e. try-catch-finally-finalize.

I have also created another class that will create 3 instances of this runnable and then we will see the execution path.

public class TryCatchFinallyTest implements Runnable < private void testMethod() throws InterruptedException < try < System.out.println("In try block"); throw new NullPointerException(); >catch(NullPointerException npe) < System.out.println("In catch block"); >finally < System.out.println("In finally block"); >> @Override protected void finalize() throws Throwable < System.out.println("In finalize block"); super.finalize(); >@Override public void run() < try < testMethod(); >catch (InterruptedException e) < e.printStackTrace(); >> >

In try block In catch block In finally block In try block In catch block In finally block In try block In catch block In finally block

Amazing, finalize() method has not been executed at all for any thread. So this proves what I stated already.

The reason which I can think of is – that finalizers are executed by a separate thread from the garbage collector. If JVM exits too early then the garbage collector does not get enough time to create and execute finalizers.

2.1. Can we force finalize() to execute?

In try block In catch block In finally block In try block In try block In catch block In finally block In catch block In finally block In finalize block In finalize block In finalize block

There is another method also: Runtime.getRuntime().runFinalization(); but, it only guarantees that GC will make its best efforts. Even our program is not able to run finalize() method for all 3 threads.

Moving forward, we have used Runtime.runFinalizersOnExit(true) . Well, this is another pit. This method has already been deprecated in JDK, for the following reason –

“This method is inherently unsafe. It may result in finalizers being called on live objects while other threads are concurrently manipulating those objects, resulting in erratic behavior or deadlock.”

So, in one way we can not guarantee the execution and in another way we the system in danger. Better, don’t use this method.

3. Other Reasons for Not Using finalize()

1. finalize() methods do not work in chaining like constructors. It means when you call a constructor then constructors of all superclasses will be invoked implicitly. But, in the case of finalize() methods, this is not followed. Ideally, parent class’s finalize() should be called explicitly but it does not happen.
2. Suppose, you created a class and wrote its finalize method with care. Someone comes and extends your class and does not call super.finalize() in subclass’s finalize() block, then super class’s finalize() will never be invoked anyhow.
3. Any exception which is thrown by finalize() method is ignored by GC thread and it will not be propagated further, in fact it will not be logged in your log files . So bad, isn’t it?

4. finalize() adds Heavy Penalty on Performance

In Effective Java (2nd edition) Joshua Bloch says:

“Oh, and one more thing: there is a severe performance penalty for using finalizers. On my machine, the time to create and destroy a simple object is about 5.6 ns. Adding a finalizer increases the time to 2,400 ns. In other words, it is about 430 times slower to create and destroy objects with finalizers.”

I also tried the above analysis on my system but I was not able to get that much difference. Although, there is some difference for sure. But that was around 30% on the original time. On time-critical systems, it is also a big difference.

5. How to Use finalize() Correctly

After all the above arguments, if you still find a situation where using finalize() is essential, then cross-check below points:

• Always call super.finalize() in your finalize() method.
• Do not put time-critical application logic in finalize() , seeing its unpredictability.
• Do not use Runtime.runFinalizersOnExit(true); as it can put your system in danger.
• Try to follow the below template for finalize() method

@Override protected void finalize() throws Throwable < try< //release resources here >catch(Throwable t)< throw t; >finally < super.finalize(); >>

In this post, we discussed Java finalize best practice, how can we call finalize method manually in Java, and why not to use finalize in Java applications.

Источник