Re: Implementing caches that may be cleared if heap space shrinks away
"Matt Humphrey" <matth@iviz.com> writes:
Hi Matt,
--8<---------------cut here---------------start------------->8---
private void initializeCache() {
words = new SoftReference<HashMap<String, WordInfo>>(
new HashMap<String, WordInfo>());
}
WordInfo getWordInfo(String word) throws RemoteException, JGWNLException {
if (words.get() == null) {
initializeCache();
} else if (words.get().containsKey(word)) {
return words.get().get(word);
}
WordInfo wi = jgwnl.lookupWord(word);
for (SynsetInfo si : wi.getSynsetInfos()) {
synsetCache.updateSynsetInfo(si.getUid(), si);
}
words.get().put(word, wi);
return wi;
}
--8<---------------cut here---------------end--------------->8---
And there may be the possibility that after the check the soft ref is
cleared before I access it...
I don't think this is true. From the javadocs on SoftReference--- "As
long as the referent of a soft reference is strongly reachable, that
is, is actually in use, the soft reference will not be cleared." At
the time you retrieve the soft reference it is either null (already
cleared) or it refers to the object. If it refers to the object it is
now strongly reachable via the local variable and will not be cleared.
This guarantee is atomic so there's no need to double check. Just
retrieve the reference and if it's not present reload it. It will
remain as long as you have a reference to it.
Ah, ok. Now I got it. Thanks for enlightening me!
Although I've not implemented caches this way I'm puzzled as to why
the entire map is under softreference rather than the individual
entries, although this is likely just a characteristic of your
particular design.
Yes, both keys and values are of small memory footprint, but there may
be millions of pairs. So maybe I could use Map<SoftRef<S>, SoftRef<T>>,
but I guess the benefits would be less than the additional complexity.
Basically, what I want is an interface Clearable which defines a
clear() method that's called automatically if heap space shrinks
away, but I couldn't find anything like that.
That is similar to what I've done (appropriate for my system). I use
direct LRU / LFU with a scavenger thread so that each entry has a
last-used-at timestamp or frequency. The scavenger invokes "cleanup"
which scans the table and drops items not being used.
But when do you invoke cleanup? Polling Runtime.freeMemory()?
Bye,
Tassilo