Lew said:
Roger said:
Roger said:
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.
I'm quite aware of what System.gc() does, what I tried to establis was
if calling it or not would make any difference to my program. If you
look closely you will see that I have three different options that could
be executed or skipped. They are:
1. Explicitly nulling the reference to the key object.
2. Requesting a GC.
3. Waiting a short while.
I also try running through all permutations of these options (the sleep
which I first tried on a whim made different results on my machine
depending on if I limited the JVM to one CPU or not).
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.
Yes it could, but my testing indicated that it did not. Would be
interesting to see if it would still generate the "OutOfMemoryException"
though.
You don't put any pressure on the heap to force weak references to go away.
But they do go away, as long as there is no local reference to the key.
And I made an other application which kept the arrays and used them for
some silly calculations, but that code made no difference, so I removed
it to make the sscce shorter.
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.
As far as I understand, a SoftHashMap will allow the referenced object
be collected IFF there are no references to the key.
Object key = new Object();
map.put(key, new DummyObject());
// more code
if the "more code" part does not use "key", then the dummy object would
be available for collection. That's what Mark Thornton wrote Java 6
would be able to do.
I do not understand your metrics, or what you mean by calling the number
of "allocate-and-discard" loops a "GC factor".
Sorry about that, the original code showed the size of the largest
allocated object as a ratio to the first allocated object. Rewrote the
code to instead use a counter but forgot to update the output.
I have no idea what your example demonstrates, except for that it is
clear that something does get collected.
Specifically, the object referenced by the SoftHashMap, but only if I
set key to null (or any other object not being used as a key in the map
I would guess).
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.
The idea was to show that objects would be collected even if references
as long as the reference would not be used any more. Sadly, that did not
work which is indicated by my first comment "I did not manage to observe
this, perhaps my program is flawed".
In the example below I use WeakHashMap which references a large int[]. I
then allocate fairly small objects until either the map releases the
large object or an OutOfMemoryError is generated. The goal is to get the
map to have a size 0 which would have shown that the object referenced
by key was collected wile key was in scope but unreachable. Sadly, this
example does not prove Mark Thornton right either. Manually setting the
key to null before the garbage generating loop will allow the large
int[] to be collected;
<sscce>
import java.util.LinkedList;
import java.util.List;
import java.util.WeakHashMap;
public class GcExample {
private WeakHashMap<Object,int[]> map =
new WeakHashMap<Object,int[]>();
public static void main(String... args) throws Exception {
new GcExample().run();
}
public void run() {
List<int[]> garbage = new LinkedList<int[]>();
try {
Object key = new Object();
map.put(key, new int[5000000]);
// Generate garbage to force key and large int[] to
// be collected.
while (map.size() > 0) {
garbage.add(new int[2000]);
}
} catch (OutOfMemoryError e) {
}
System.out.format("Large int[] collected: %b. Allocations %d%n",
map.size() == 0, garbage.size());
}
}
</sscce>
//Roger Lindsjö
.