Difference between WeakReference vs SoftReference vs PhantomReference in Java? Example

WeakReference and SoftReference were added into Java API for a long time but not every Java programmer is familiar with it. This means there is a gap between where and how to use WeakReference and SoftReference in Java. Reference classes are particularly important in the context of How Garbage collection works. As we all know that Garbage Collector reclaims memory from objects which are eligible for garbage collection, but not many programmers know that this eligibility is decided based upon which kind of references are pointing to that object. This is also the main difference between WeakReference and SoftReference in Java.

The garbage collector can collect an object if only weak references are pointing towards it and they are eagerly collected, on the other hand, Objects with SoftReference are collected when JVM absolutely needs memory.

This special behavior of SoftReference and WeakReference makes them useful in certain cases like SoftReference looks perfect for implementing caches, so when JVM needs memory it removes objects which have only SoftReference pointing towards them.

On the other hand, WeakReference is great for storing metadata e.g. storing ClassLoader reference. If no class is loaded then no point in keeping a reference of ClassLoader, a WeakReference makes ClassLoader eligible for Garbage collection as soon as the last strong reference is removed.

In this article, we will explore some more about the various references in Java e.g. Strong reference and Phantom reference.

WeakReference vs SoftReference in Java? Example

For those who don't know there is four kinds of references in Java :

1. Strong reference
2. Weak Reference
3. Soft Reference
4. Phantom Reference

Strong Reference is most simple as we use it in our day to day programming life e.g. in the code, String s = "abc" , reference variable s has strong reference to String object "abc". Any object which has Strong reference attached to it is not eligible for garbage collection. Obviously these are objects which is needed by Java program. Weak Reference are represented using java.lang.ref.WeakReference class and you can create Weak Reference by using following code :

Counter counter = new Counter(); // strong reference - line 1
WeakReference<Counter> weakCounter = new WeakReference<Counter>(counter); 
//weak reference
counter = null; // now Counter object is eligible for garbage collection

Now as soon as you make strong reference counter = null, counter object created on line 1 becomes eligible for garbage collection; because it doesn't have any more Strong reference and Weak reference by reference variable weakCounter can not prevent Counter object from being garbage collected.  

On the other hand, had this been Soft Reference, Counter object is not garbage collected until JVM absolutely needs memory. Soft reference in Java is represented using java.lang.ref.SoftReference class. You can use the following code to create a SoftReference in Java

Counter prime = new Counter();  // prime holds a strong reference - line 2
SoftReference<Counter> soft = new SoftReference<Counter>(prime) ; 
//soft reference variable has SoftReference to Counter Object created at line 2

prime = null;  // now Counter object is eligible for garbage 
              // collection but only be collected when JVM absolutely needs memory

After making strong reference null, Counter object created on line 2 only has one soft reference which can not prevent it from being garbage collected but it can delay collection, which is eager in case of WeakReference. Due to this major difference between SoftReference and WeakReference, SoftReference are more suitable for caches and WeakReference are more suitable for storing metadata. 

One convenient example of WeakReference is WeakHashMap, which is another implementation of Map interfaces like HashMap or TreeMap but with one unique feature. WeakHashMap wraps keys as WeakReference which means a once strong reference to actual object removed, WeakReference present internally on WeakHashMap doesn't prevent them from being garbage collected.

Phantom reference is the third kind of reference type available in java.lang.ref package. Phantom reference is represented by java.lang.ref.PhantomReference class. Object which only has Phantom reference pointing them can be collected whenever Garbage Collector likes it. Similar to WeakReference and SoftReference you can create PhantomReference by using the following code :

DigitalCounter digit = new DigitalCounter(); 
// digit reference variable has strong reference - line 3

PhantomReference<DigitalCounter> phantom 
= new PhantomReference<DigitalCounter>(digit); 
// phantom reference to object created at line 3

digit = null;

As soon as you remove Strong reference, the DigitalCounter object created at line 3 can be garbage collected at any time as it only has one more PhantomReference pointing towards it, which can not prevent it from GC'd.

Apart from knowing about WeakReference, SoftReference, PhantomReference, and WeakHashMap, there is one more class called ReferenceQueue which is worth knowing. You can supply a ReferenceQueue instance while creating any WeakReference, SoftReference or PhantomReference as shown in the following code :

ReferenceQueue refQueue = new ReferenceQueue(); 
//reference will be stored in this queue for cleanup

DigitalCounter digit = new DigitalCounter();
PhantomReference<DigitalCounter> phantom 
= new PhantomReference<DigitalCounter>(digit, refQueue);

Reference of instance will be appended to ReferenceQueue and you can use it to perform any clean-up by polling ReferenceQueue. An Object's life-cycle is nicely summed up by this diagram.

That's all on the difference between WeakReference and SoftReference in Java. We also learned the basics of reference classes e.g. Weak, soft, and phantom reference in Java and WeakHashMap and ReferenceQueue. Careful use of reference can assist Garbage Collection and result in better memory management in Java.