Comments on Code Instructions: Weak Object Pools with WeakHashMap

Yep, and it works nicely. Hence why I got confused...

2011-12-19T11:41:10.028-05:00

Yep, and it works nicely. Hence why I got confused when I thought this article was the same as my usecase. I thought I must be missing something, and indeed I was, some glasses ;)

Hi KieronW, This is exactly what the WeakHashMap ...

2011-12-19T10:39:10.859-05:00

Hi KieronW,

This is exactly what the WeakHashMap is for!

Ah, sorry. I have totally confused the situation b...

2011-12-19T05:44:03.710-05:00

Ah, sorry. I have totally confused the situation by not reading your second article properly.
What I was trying to do is create basically a short-term cache, not an object pool like you
are doing here.

Basically this:

String[] expressionStrs = createExpressions(); // a large number, with many duplicates
for (String expressionStr : expressionStrs) {
Expression expression = expensiveParse(expressionStr);
result.add(expression);
}

So what I was trying to do is use a cheap WeakHashMap[String,Expression] cache that only parses
expressions if it is genuinely different to previous ones. Once the expressionStrs falls out of
scope, and GC runs, my WeakHashMap becomes empty. Then, once I have finished with my expressions,
I get all my memory back.

Cheap (I don't want stuff to stick around like SoftReferences do) and easy to manage.

But of course, totally different to what you are doing here. So I guess this was more appropriate
for your first article - WeakHashMap can be used for a very specific type of cache. :)

Anyway thanks, I found your article very informative.

Hi KieronW, You can run this simple test to see w...

2011-12-16T12:41:55.432-05:00

Hi KieronW,

You can run this simple test to see what I'm talking about:

WeakHashMap<String, String> map = new WeakHashMap<String, String>();

String value1 = new String("value1");

map.put(value1, value1);

System.gc();

System.out.println(map.get("value1"));

value1 = null;

System.gc();
System.out.println(map.get("value1"));

This will print:
value1
value1

Which means the second call to System.gc() did not clear the map even though you cleared the strong reference in the previous line.

Now if you do this:

WeakHashMap<String, WeakReference<String>> map = new WeakHashMap<String, WeakReference<String>>();

String value1 = new String("value1");

map.put(value1, new WeakReference<String>(value1));

System.gc();

System.out.println(map.get("value1").get());

value1 = null;

System.gc();
WeakReference<String> wref = map.get("value1");
String ref = null;
if (wref != null) {
ref = wref.get();
}
System.out.println(ref);

Then you will get:

value1
null

Thanks for the quick answer! I was quite confused ...

2011-12-16T12:14:55.816-05:00

Thanks for the quick answer! I was quite confused by the behaviour, so I had a look in the WeakHashMap class. It looks like it does get rid of map entries - done in the expungeStaleEntries() method - but it seems it only ever does it when there are operations performed on the map (and after keys have been GC'ed). However, if your map is in constant use, it does look like the values are also cleared out, and it uses the ReferenceQueue for this.

I could be wrong here, so I'll have a look at the weekend and see if I can verify it in code.

Hi KieronW, We have to wrap the object in a WeakR...

2011-12-16T12:00:23.093-05:00

Hi KieronW,

We have to wrap the object in a WeakReference because if we didn't, then there would be a strong reference to that object and it would never be garbage collected.

Remember the WeakHashMap useas WeakReferences for the keys, but strong references for the values. The garbage collector decides whether to garbage collect an object based on the strongest type of reference to that object. In this case, every object in the map would have a strong reference pointing at it, so nothing would be garbage collected.

Hi there. Just one question. Why are you wrapping ...

2011-12-16T04:14:02.315-05:00

Hi there. Just one question. Why are you wrapping the objects in a WeakReference? Wouldn't the whole map entry get discarded given the keys are weak?

I ask particularly because on Oracle's website they seem to imply that this is only needed if your values refer to your keys (and hence hold a strong reference to them, and the entry would never be discarded)?

http://docs.oracle.com/javase/6/docs/api/java/util/WeakHashMap.html

Looks like you misread the code Scott. The *values...

2011-04-18T21:56:22.323-04:00

Looks like you misread the code Scott.
The *values* are being wrapped in a WeakReference, not the keys.

If you just put the object itself in the map with map.put(object, object) then there would be a strong reference to object as the WeakHashMap class only wraps keys in WeakReferences

I know this is an old post, but I think it's w...

2011-04-08T11:25:47.899-04:00

I know this is an old post, but I think it's worth noting for anyone else that comes across it that the WeakHashMap class uses WeakReference objects internally. By wrapping the key in a WeakReference object yourself you are just adding unnecessary overhead. Each key you set will end up being a WeakReference object pointing to a WeakReferenceObject pointing to the actual key.

The contents of the replace function should be more like:

Object current = map.get(object);
if(current != null)
return current;
map.put(object, object);
return object;

Nice, I liked the auto cleanup that you earn here....

2009-08-28T18:06:48.407-04:00

Nice, I liked the auto cleanup that you earn here. I'm sure I'll use it someday.

Just a small comment about the need to use this for Integer caching, the Integer class already implements a small cache for the frequent -127-128 value. I've written about it here in my blog

it's very good.but i have a doubt that if the Weak...

2008-11-18T06:30:00.000-05:00

it's very good.but i have a doubt that if the WeakHahMap object is garbage collected or else if it takes more memory then.sorry if iam foolish

Hi Felipe, it surely doesn't sound stupid. In tha...

2008-09-29T19:09:00.000-04:00

Hi Felipe, it surely doesn't sound stupid. In that example, it is true that there wouldn't be any difference between using a HashSet or a WeakObjectPool. I wrote the example to be as simple as possible on purpose in order to improve readability and it turns out I simplified it so much that the benefit wasn't clear.

To really take advantage of the instance pool you would have to make it a singleton so that you can reuse instances between unrelated method invocations. It would be even better to make it thread safe and then you can share the same instance pool among threads.

Sorry if this sounds stupid, but what would be the...

2008-09-26T17:07:00.000-04:00

Sorry if this sounds stupid, but what would be the difference, on the CSV example, of having a Weak Object Pool over a HashSet, for instance?

I understand that the key benefit would be if you use all the values from the CSV while processing and, later on, you no longer reference them all, allowing the weak references to be collected.

Am I right or missing something :) ?