Is object memory freed when we explicitly call finalize ()?

Question

As far as I understand, finalize () and GC are two different aspects. GC uses the finalize () method to free Object memory. We cannot indicate when the GC will happen (even if we explicitly call System.gc ()). But we can explicitly call finalize () on the object.

Will the function be executed immediately(memory freed) or it waits till GC occurs like System.gc() call? 

Also, according to the docs, the finalize method is never called more than once by the Java virtual machine for any given object.

So what happens when we call finalize () and the GC happens at a later point in time.

 If object memory is not freed on explicit call to object.finalize() then would't it being called again in the GC process violate the calling only once rule? 

Answer 1

This is completely wrong with you.

Short answer: finalize() is a tool for cleaning resources (such as open files) just before an object is ready to collect garbage (when no object has a link to it). This may / may not be caused. This is one step ahead of freeing up memory.

Long answer:

There is a separate daemon thread called the finalizer thread, which is responsible for calling the finalize () method. A finalization queue is a queue in which objects are placed that are ready to call the finalize () method.

• When an object is created, the JVM checks to see if the user has overridden the finalize () method. If it is then, it internally notes that this particular object has a finalize () method.

When the object is ready for garbage collection, the garbage collector thread checks if this particular object () is complete from the table specified in (1).

• 2a) If this is not the case, it is sent to collect garbage.

  2b) He has, then he is added to the finalization queue. And it removes the object record from the table (1).

The finalizer continues to track the queue. For each object in the queue, the finalize () method is called. After calling the loop, finalize () from (2) is repeated again. If this object still does not have a strong reference, then it is sent for the GC. If he has then ALWAYS (2a), because the record has been deleted in (2b)

 Basically finalize() method is only called once. 

So what is the problem with the above loop?

From (1). It will take extra time to create the object. Java memory allocation is 5 to 10 times faster than malloc / calloc, etc. All the time received is lost in the procedure for notifying an object in a table, etc. I tried it once. Create 100,000 objects in a loop and measure the time taken to complete the program in 2 cases: one without finalize (), the second with finalize (). Found it 20% faster.

From (2b): Memory leak and starvation. If an object in the queue has references to many memory resources, then all these objects will not be freed if this object is not ready for the GC. If all objects are objects with a heavy weight, then there may be a shortage.

From (2b): Since finalize () is called only once, what if in finalize () you had a strong reference to the "this" object. The next time the finalie () objects are never called, therefore, it can leave the object in an inconsistent state.

If an exception is thrown inside finalize (), it is ignored.

You do not know when finalize () is called, since you have no control over the GC call. It can sometimes happen that you print the values ​​in finalize (), but the output is never displayed because your program could have been completed by the time finalize () was completed.

Therefore, avoid using it. Instead, create a say dispose () method that closes the required resources or the final log, etc.

Answer 2

In accordance with the documents:

The finalize method is never called more than once by the Java virtual machine for any given object.

However, you cannot get GC to work, you can simply ask for it through System.gc() . Thus, the best approach is that when you override the code, finalize() code is freed.

Answer 3

The answers are in the Object.finalize API

1) GC calls finalize (), so finalize () and GC are not two different aspects.

2) You should not call finalization manually, but if you do, it will not free memory and will not affect the behavior of the GC

3) They say that it guarantees that the GC will not cause completion twice, our calls are not considered