Soft References in Java

1. Overview

In this quick article, we’ll be talking about soft references in Java.

We’ll explain what they are, why we need them, and how to create them.

2. What Are Soft References?

A soft reference object (or a softly reachable object) can be cleared by the Garbage Collector in response to a memory demand. A softly reachable object has no strong references pointing to it.

When a Garbage Collector gets called, it starts iterating over all elements in the heap. GC stores reference type objects in a special queue.

After all objects in the heap get checked, GC determines which instances should be removed by removing objects from that queue mentioned above.

These rules vary from one JVM implementation to another, but the documentation states that all soft references to softly-reachable objects are guaranteed to be cleared before a JVM throws an OutOfMemoryError.

Though, no guarantees are placed upon the time when a soft reference gets cleared or the order in which a set of such references to different objects get cleared.

As a rule, JVM implementations choose between cleaning of either recently-created or recently-used references.

Softly reachable objects will remain alive for some time after the last time they are referenced. The default value is a one second of lifetime per free megabyte in the heap. This value can be adjusted using the -XX:SoftRefLRUPolicyMSPerMB flag.

For example, to change the value to 2.5 seconds (2500 milliseconds), we can use:

-XX:SoftRefLRUPolicyMSPerMB=2500

In comparison to weak references, soft references can have longer lifetimes since they continue to exist until extra memory is required.

Therefore, they’re a better choice if we need to hold objects in memory as long as possible.

3. Soft References’ Use Cases

Soft references can be used for implementing memory-sensitive caches where memory management is a very important factor.

As long as the referent of a soft reference is strongly reachable, that is – is actually in use, the reference won’t be cleared.

A cache can, for example, prevent its most recently used entries from being discarded by keeping strong referents to those entries, leaving the remaining entries to be discarded at the discretion of the Garbage Collector.

4. Working With Soft References

In Java, a soft reference is represented by the java.lang.ref.SoftReference class.

We have two options to initialize it.

The first way is to pass a referent only:

StringBuilder builder = new StringBuilder();
SoftReference<StringBuilder> reference1 = new SoftReference<>(builder);

The second option implies passing a reference to a java.lang.ref.ReferenceQueue as well as a reference to a referent. Reference queues are designed for making us aware of actions performed by the Garbage Collector. It appends a reference object to a reference queue as it decides to remove the referent of this reference.

Here’s how to initialize a SoftReference with a ReferenceQueue:

ReferenceQueue<StringBuilder> referenceQueue = new ReferenceQueue<>();
SoftReference<StringBuilder> reference2
 = new SoftReference<>(builder, referenceQueue);

As a java.lang.ref.Reference, it contains the methods get and clear to get and reset a referent respectively:

StringBuilder builder1 = reference2.get();
reference2.clear();
StringBuilder builder2 = reference2.get(); // null

Each time we work with this kind of references, we need to make sure that a referent, returned by the get, is present:

StringBuilder builder3 = reference2.get();
if (builder3 != null) {
    // GC hasn't removed the instance yet
} else {
    // GC has cleared the instance
}

5. Conclusion

In this tutorial, we got familiar with the concept of soft references and their use cases.

Also, we’ve learned how to create one and work with it programmatically.