Reading time: 25 minutes | Coding time: 10 minutes
One of the most popular facilities in the Java Virtual Machine is the Garbage Collector. It is responsible for scanning the memory in runtime, locating and deleting the objects that will no longer be used by the Java Virtual Machine (JVM). Hence, it manages the memory resources this way and takes away this obligation from the developer.
Although, the Garbage Collector behaves slightly different depending on the types of reference that is attached to an object. This allowing the programmer to control memory resources if required by the application.
There are 4 types of reference in Java Language:
- Strong Reference
- Weak Reference
- Soft Reference
- Phantom Reference
Strong References are the most common type of reference in Java. Every time we directly point a variable to an object, we are indeed strongly linking a memory section to our application.
Object obj = new Object(); // Creates a strong reference
With just one line of code, the Java Virtual Machine separates space in memory, instantiating a new object from a class, and give to the developer a way to interact with it through the
obj variable. This communication only happens while the program has a memory reference, determined by
obj. At the moment that the variable value changes to another object - or null - we will be lost the interaction with the first object, and the Garbage Collector can go into action.
The primary rule from the Garbage Collector resumes to: reclaim any memory space with no strong references pointing to it.
The image above can illustrate this condition when the null value is attached to the variable and abandon the object in memory. However, despite this behavior, there are other types of references who change the GC response and can create useful situations for a Java application.
Soft References are a special kind of reference, which slightly changes the default behavior of the Garbage Collector, allowing the GC to maintain objects without strong references until the Java Virtual Machine runs out of memory. In this last case, the Garbage Collector will try to save the application scanning the memory and deleting all the soft references.
So, even if a variable does not refer directly to an object, this one can be ignored by the GC while the JVM doesn't need more resources. A representation of this indirectly reference it's described in the image below.
The following code shows how to implement a soft reference using the
SoftReference class. To use this and the other types of reference resources it simply has to import the
import java.lang.ref.* // ... Object obj = new Object(); // New Soft Reference to obj object SofReference<Object> softRef = new SoftReference<Object>(obj);
Notice in the code above we have a soft and two strong references, this happens because all the variables and objects directly accessible by programming are strong references. If we change the
obj value to another memory address and maintain the
softRef value, it becomes soft reachable. The GC will reclaim this memory space only in the lack of resources.
This feature can be useful for objects with dynamic use, which are frequently changed but the cost to create a new object are too expensive, just like in object pools. Which tries to increase performance always having one of these classes instantiated in memory, but much of the time the objects may even be ignored by the JVM and can be deleted.
Weak References have another interpretation from the Garbage Collector. While the types mentioned before are, for default, preserved in memory, if an object has only a weak reference attached to him when the GC is running, then it will be reclaimed even if the virtual machine doesn't need more space.
We can create a new weak reference using the WeakReference class, just like showed before with the
SoftReference. We can also use the
get() method for rescue the object from both soft and weak reference. But, if the GC has already reclaimed the memory space, then the
get() method will return null.
Object obj = new Object(); // New Weak Reference to obj object WeakReference<Object> softRef = new WeakReference<Object>(obj); // Removing the Strong Reference obj = null; // Explicit call of the Garbage Collector System.gc(); // Returns the object reference if it remains in memory, // otherwise returns null obj = softRef.get();
This can be useful to implement cache data and hash maps. Being able to be discarded at any time, or also too large objects which the developer wants to make sure they were deleted and don't have copies in memory.
The last type of reference it's even more special than the mentioned before. The Garbage Collector can delete phantom referenced objects, but before that, the JVM append the reference object in a queue named "Reference Queue" responsible for telling to the application when the GC removes the phantom referenced object from memory. For this case, the
get() method always return null.
Object obj = new Object(); // Creating a reference queue ReferenceQueue<obj> refQueue = new ReferenceQueue<obj>(); // New Phantom Reference to obj object in a queue PhantomReference<Object> phantomRef = new PhantomReference<Object>(obj, refQueue); // Removing the Strong Reference obj = null; // Explicit call of the Garbage Collector System.gc(); // get() method always returns null phantomRef.get();
When an object becomes phantom reachable - only have phantom references - the GC will append it in the
refQueue at the final of its iteration. We can recover this information using the
poll() method from the reference queue class.
// Removing the Strong Reference obj = null; System.out.println("Queue: " + queue.poll()); // empty queue // Explicit call of the Garbage Collector System.gc(); System.out.println("Queue: " + queue.poll()); // show PhantomReference object
A developer can use this resource to have sure that an object was deleted or not. Also, it can be used to make cleanup actions more flexible without explicit override the
With the types of references, a Java developer can have access to mechanisms to advanced memory management. These features allow to dynamically change the Garbage Collector behave, handing some of its powers to the programmer.