For a description of what happens to finalizable objects (and a bit
about why using them isn't such a good idea), take a look at
http://java.sun.com/developer/technicalArticles/javase/finalization/
Another potential problem is that since the finalization queue is
processed in a single thread (I think...), if you have high churn of
finalizable objects you can get OOM errors as the queue backs up.
charlie hunt wrote:
> Oleksiy Stashok wrote:
>> Hi Charlie,
>>
>>> I haven't had a chance to look in detail at the implementation
>>> details of the SlabMemoryManager and how it's used. But, I did
>>> notice in the object diagram for Slab, a finalize() method.
>>> Depending on how Slab and the classes that inherit Slab are used, we
>>> might consider looking into the possibility of migrating to using a
>>> "ReferenceQueue" approach to clean things up rather than using
>>> finalize().
>>>
>>> finalize() can be problematic in that it may take several gc events
>>> for an object with a finalize() method to get collected.
>> I see, currently we override finalize just for statistics reasons (we
>> calculate total amount of reclaimed memory). In this case, IMHO, we
>> can just make sure, that even if finalize() is called several times
>> for single object - we will calculate statistics right way.
>>
>
> What I really meant by "finalize() can be problematic in that it may
> take several gc events for an object with a finalize() method to get
> collected." is that using a finalizer in general is problematic, not
> anything specific about what Slab.finalize() was doing as being
> problematic. It's the use of a finalizer itself.
>
> In short, any object with a finalize() method will most of the time
> require at least 2 gc events to be fully garbaged collected. The
> first gc event usually just puts the object on the finalizer queue,
> the 2nd gc event will then execute the finalize() method and finish
> collecting it. In cases where the finalizer queue depth is deep, the
> entire queue may not get cleared in one gc event. In such as case, an
> object with a finalize() method may sit on on the finalizer queue for
> multiple gc events beyond the first gc event place the object on the
> finalizer queue. So, it is possible in some circumstances for an
> object with a finalize() method to take more than 2 gc events to be
> collect, (1 gc event to get put on the finalizer queue, 1 or more
> additional gc events to get pulled off the finalizer queue and be
> executed).
>
> In short, it's best to avoid using a finalize() method.
>
> Hope that makes more sense?
>
> thanks,
>
> charlie ...
>> Thanks.
>>
>> WBR,
>> Alexey.
>>
>>>
>>>
>>> charlie ...
>>>
>>> ---------------------------------------------------------------------
>>> To unsubscribe, e-mail: dev-unsubscribe_at_grizzly.dev.java.net
>>> For additional commands, e-mail: dev-help_at_grizzly.dev.java.net
>>>
>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: dev-unsubscribe_at_grizzly.dev.java.net
>> For additional commands, e-mail: dev-help_at_grizzly.dev.java.net
>>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: dev-unsubscribe_at_grizzly.dev.java.net
> For additional commands, e-mail: dev-help_at_grizzly.dev.java.net
>