Soft reference LinkedHashMap in Java?

Question

Is there softreference-based LinkedHashMap in Java? If no, has anyone got a snippet of code that I can probably reuse? I promise to reference it correctly.

Thanks.

Answer 1

have a look at this post. It shows how to implement a SoftHashMap...

Answer 2

WeakHashMap doesn't preserve the insertion order. It thus cannot be considered as a direct replacement for LinkedHashMap. Moreover, the map entry is only released when the key is no longer reachable. Which may not be what you are looking for.

If what you are looking for is a memory-friendly cache, here is a naive implementation you could use.

package be.citobi.oneshot;

import java.lang.ref.SoftReference;
import java.util.LinkedHashMap;

public class SoftLinkedCache<K, V>
{
    private static final long serialVersionUID = -4585400640420886743L;

    private final LinkedHashMap<K, SoftReference<V>> map;

    public SoftLinkedCache(final int cacheSize)
    {
        if (cacheSize < 1)
            throw new IllegalArgumentException("cache size must be greater than 0");

        map = new LinkedHashMap<K, SoftReference<V>>()
        {
            private static final long serialVersionUID = 5857390063785416719L;

            @Override
            protected boolean removeEldestEntry(java.util.Map.Entry<K, SoftReference<V>> eldest)
            {
                return size() > cacheSize;
            }
        };
    }

    public synchronized V put(K key, V value)
    {
        SoftReference<V> previousValueReference = map.put(key, new SoftReference<V>(value));
        return previousValueReference != null ? previousValueReference.get() : null;
    }

    public synchronized V get(K key)
    {
        SoftReference<V> valueReference = map.get(key);
        return valueReference != null ? valueReference.get() : null;
    }
}

Answer 3

The best idea I've seen for this is wrapping LinkedHashMap so that everything you put into it is a WeakReference.

UPDATE: Just browsed the source of WeakHashMap and the way it handles making everything a WeakReference while still playing nice with generics is solid. Here's the core class signature it uses:

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>

I suggest browsing the source more in depth for other implementation ideas.

UPDATE 2: kdgregory raises a good point in his comment - all my suggestion does is make sure the references in the Map won't keep the referent from being garbage-collected. You still need to clean out the dead references manually.