The following code instantiates an instance of Student class in the heap and references the created instance from the stack variable s.
Student s = new Student();
The instantiated Student object remains in the heap until it is reachable by at least one reference to it. When the garbage collector runs after the last object reference has been removed, the object is deleted from heap.
In the above example, s is a strong reference to the Student object. The garbage collector will not remove objects that have a strong reference.
When strong references fall short
There are times when a object should be marked as garbage collectible even when there are active references to it. For example, consider a large image object held in a in-memory cache. This image object should remain in the heap as long as the caching API's clients have reference to the image object. But if the caching API uses strong references, the image object will never get garbage collected as there will always be a strong reference to the image object from the cache itself. Enter weak references.
In the above caching example, the caching API should use a
WeakReference. A
weak reference "is a reference that isn't strong enough to force the object to remain in memory".
WeakReference weakStudent = new WeakStudent(new Student());
weakStudent.get(); // Returns actual Student object
The weakStudent.get() call could potentially return null if there are no strong references to the Student object.
A
WeakHashMap is similar to HashMap except that the keys (not values) are referred to using weak references. So when there are no other Strong references to a key, it will be removed from the map.
Once WeakReference.get() starts returning null, the reference has become garbage collectible and the WeakReference is of no good. The
ReferenceQueue class helps keep track of such garbage collectible references and should be passed as argument to WeakReference's constructor. When a object becomes garbage collectable, it will be placed in the ReferenceQueue. The application can read this queue from time to time and perform clean up on its end.
Degrees of weakness
A WeakReference is only one flavor of weakness. There are 2 more flavors:
1.
SoftReference - This is less weak than a WeakReference. In a WeakReference, the referenced object is garbage collected the next time garbage collector runs, irrespective of whether memory is in shortage or not. A SoftReference is garbage collected only when memory is in short supply.
2.
PhantomReference - This is stronger than a WeakReference. Its get() method always returns null. Its only use is to figure out when the object is enqueued into ReferenceQueues. For a WeakReference, the object is queued as soon as its only weakly reachable. Even before finalization and actual garbage collection. For PhanthomReference, the object is queued only after the object is physically removed from memory.
