"raghu" <raghujindia@gmail.com> wrote in news:1134927095.209719.312850
@g44g2000cwa.googlegroups.com:

So your teacher gave you a list of questions and expects you to think about
them and come up with a good answer, correct?  May I suggest you actually
do think about them, instead of asking us.  Perhaps if you at least show
that you thought about it by posting your thoughts, the group would be more
likely to point you in the right direction.

Because it may not be possible for garbage collection work to be done
right now.  The virtual machine, languagem, and API specifications leave
open the possibility for a wide variety of garbage collection
implementations, and so no assumption is made that garbage collection is
possible at arbitrary times.

The contract for System.gc() makes two discrete guarantees:

1. "Calling the gc method suggests that the Java Virtual Machine expend
effort toward recycling unused objects in order to make the memory they
currently occupy available for quick reuse."

2. "When control returns from the method call, the Java Virtual Machine
has made a best effort to reclaim space from all discarded objects."

It's distressingly common to see people quote #1 rather ferociously, and
then ignore #2.  So to reiterate, you are GUARANTEED that when the
system returns from System.gc(), a best effort has been made to perform
any garbage collection work that can be done.  The two statements --
"suggests" and "best effort" -- are reconciled in that it's possible
that no garbage collection effort is possible at all, in which case a
best effort is equivalent to no effort at all.

How is that possible?  Two ways, that I can think of:

1. Perhaps there is never any deferred garbage collection work in this
implementation of the JVM.  For example, perhaps it's a variant on
reference counting with magic to collect cycles deterministically.

2. Perhaps situations aren't right... for example, maybe it's a
distributed JVM, and there's a network link down that prevents it from
scanning the stacks of threads that are running on a different host.

The definition of "best effort" is left rather vague, as well.  Since
software is written in advance, you could argue (circularly, of course,
and rather unconvincingly) that a software's best effort always consists
of doing whatever its code tells it to do... and thus any JVM conforms
to that requirement by definition.  However, most people would recognize
that as word games.  In the end, it comes down to the intuition of the
virtual machine implementor what corresponds to a "best effort" of the
existing software, versus changing the software itself.  I'd say that if
a garbage collection can be performed using the exposed API of the
garbage collection module (however that's defined), then the VM is
required to do it by the API specification.

In practice, all common used garbage collectors do run garbage
collection in response to a call to System.gc().  Barring unusual
circumstances, it would almost surely be a violation of the API contract
not to do so.

To protect you from foolishness. There is no point in doing GC unless
you would actually get substantial RAM back..   You as programmer
can't know that.