Re: Put releasing resource process in Object.finalize() is !! safe.

Excellent research. If you mention this to an interviewer, you will look good.
The finalizer technique is widely used, which may not always imply effectiveness. The basic idea is, if my object (for example, a shopping cart object) holds a reference to a resource like a DB connection, then in my object’s finalize(), it ought to release the resource. Logically sound ideas like this are not always 100% reliable, but still effective in my humble opinion.
“Defensive programming in-depth” suggests “design more than one layer of protection”. If one layer is not “safe” as in this case, another layer may protect us.
Therefore, we should use both 1) finalizer and 2) finally(), if possible.
My new company (I should slowly learn to avoid mentioning my company’s name) uses the finally{} technique in a lot of classes. I think probably every time a method gets a db connection, there’s a finally() in that method.
I feel DB connection release is important. Some DB vendors charge license fees based on max simultaneous connections. If we pay x dollars for 20 simultaneous connections, then those 20 simultaneoud connections become a potential bottleneck. As soon as you release the connection, another (waiting) thread can use it to read/write data.
3) A third idea (?) — An architect can instruct programmers to explicitly release resource as soon as they are done. Programmers are busy and forgetful, though. That’s why architects like the finalizer idea.
4) Do you think a DB can detect idle connections and close them after x minutes of inactivity? Do you think a connection pool manager can?
Thanks for the excerpt. Quite relevant for me.
On 11/7/07, rong xia

Hi, Tan Bin,

We have ever discussed about garbage collection.
You mentioned a question that I can just roughly recall as: How do you make sure to release resource, such as DB connection or something else?
I answered without any hesitation: put it in the Object.finalize(). And it seems you agreed with me.
But I found it’s not correct, because of the following reasons: I copied and pasted.
=========================
As you program in Java, you must keep in mind that it is the garbage collector that runs finalizers on objects. Because it is not generally possible to predict exactly when unreferenced objects will be garbage collected, it is not possible to predict when object finalizers will be run. As mentioned in Chapter 2, “Platform Independence,” you should avoid writing programs for which correctness depends upon the timely finalization of objects. For example, if a finalizer of an unreferenced object releases a resource that is needed again later by the program, the resource will not be made available until after the garbage collector has run the object finalizer. If the program needs the resource before the garbage collector has gotten around to finalizing the unreferenced object, the program is out of luck.
=========================
So, simply put the process in the Object.finalize() is not safe.
I can think of putting the process in finally statement block in a logic block.
Do you have any other good ideas to achieve this requirement?

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s