Re: how many objects r eligible for garbage Collection ?
Roger Lindsj? wrote:
Roger Lindsj? wrote:
Mark Thornton wrote:
Roger Lindsj? wrote:
The Card object references by c2 might be available too, depending
on what "// do stuff" does with it. Many (all?) GC implementations
seem to not collect objects referenced by variables still on the
stack, but I don't think they are forced to.
Java 6 does collect objects where the only references have no further
use. It is possible to observe this behaviour if you also have a weak
reference to the 'garbage'.
I did not know that it was implemented for Java 6. Will write a sscce
to show this.
I did not manage to observe this, perhaps my program is flawed. I'm
running on:
java version "1.6.0_04"
Java(TM) SE Runtime Environment (build 1.6.0_04-b12)
Java HotSpot(TM) Server VM (build 10.0-b19, mixed mode)
<sscce>
import java.util.WeakHashMap;
public class GcExample {
private WeakHashMap<Object, Object> map =
new WeakHashMap<Object, Object>();
public static void main(String... args) throws Exception {
GcExample g = new GcExample();
g.add(false, false, false);
g.add(false, false, true);
g.add(false, true, false);
g.add(false, true, true);
g.add(true, false, false);
g.add(true, false, true);
g.add(true, true, false);
g.add(true, true, true);
}
public void add(boolean nullify, boolean gc, boolean sleep)
throws Exception {
int garbageLoops = 0;
try {
Object key = new Object();
map.put(key, new byte[20000]);
if (nullify) {
key = null;
}
if (gc) {
System.gc();
}
if (sleep) {
Thread.sleep(100);
}
// Generate garbage
while (map.size() > 0) {
byte[] b = new byte[1000000 * (garbageLoops + 1)];
garbageLoops++;
}
} catch (OutOfMemoryError e) {
} finally {
System.out.format(
"Pass:%-5b Nullify:%-5b GC:%-5b Sleep:%-5b GC factor:%d%n",
map.size() == 0, nullify, gc, sleep, garbageLoops);
map.clear();
}
}
}
</sscce>
How does this demonstrate that objects are or are not collected after they go
out of use?
The System.gc() call is going to invoke major collections, if any, and there's
no guarantee of that. We don't know if the reference analyzer works on
objects that have been tenured, or if suggested GCs interfere with the
heuristics. OK, you might know, but I don't and there aren't any comments
about that in the example.
The loop around the byte [] allocation only leaves one array to test at the
end of the loop - all the arrays allocated in all but the last iteration are
eligible for GC by virture of not having a reference any more, which is not
the behavior under test. The method ends just after the last iteration, so
everything in the method is immediately available for GC at method return anyway.
A good optimizer might eliminate the allocation of 'b' at run time since the
array is not used.
You don't put any pressure on the heap to force weak references to go away.
The averred scenario, that an object will potentially be collected when there
is a reference to it but that reference is no longer used, is not represented
in the example that I can see.
I do not understand your metrics, or what you mean by calling the number of
"allocate-and-discard" loops a "GC factor".
I have no idea what your example demonstrates, except for that it is clear
that something does get collected.
Would you please explain the example and how it is designed to demonstrate
what it purports to demonstrate? For that matter, please explain what it
purports to demonstrate.
--
Lew