Self releasing (reference counting) singelton

Question

Consider the following scenario: You have a singleton class that represent some sort of data provider. This singleton class allocates a lot of memory,and you want it to release it's allocated memory when there is no one using him. Flow:

1. Class A call getInstance and uses singleton (this is the first time getInstance called and singleton class allocates huge memory chunk)
2. Class B call getInstance and uses singleton
3. Class A and class B "dies" (no one using singleton now)
4. Program still running but singleton's memory is not released.

How do you suggest implementing singleton that at stage 3 (class A and B "dies") will free the memory (I know that java uses garbage collection but still lets say I want the following memory = null).

PS I don't want to force each class that uses the singleton call release on singleton whenever it stops using it. I want the singleton to handle "releasing" memory by himself.

Answer 1

What you can do is

• only create the singleton the first time it is asked for.
• store it in a WeakReference. This will only stay alive after a GC if it is still has a "strong" reference elsewhere.

If the WeakReference.get() is null this means it was collected because no-one was using it strongly, another weak reference doesn't count. If it is needed again you need to recreate it and the WeakReference.

Like this,

public enum SingletonHolder{; // no instances

    private static WeakReference<MyType> ref = null;

    public static synchronized MyType getInstance() {
         MyType type = ref == null ? null : ref.get();
         if (type == null)
             ref = new WeakReference<MyType>(type = new MyType());
         return type;
    }
}

BTW This assumes the instances which need this instance retains a reference to it. This is how the weak reference "knows" it is still needed.

BTW2 You don't need synchronized if it is single threaded but it should be harmless.

This means that you should call this method only when a new instance needs it for the first time, not every time and making it more performant shouldn't make much difference e.g. double checking just complicates it.