Introduction to Java References
One of the advantages of the Java language is that it automatically manages the memory programmer no need to take the burden of memory management and also no need to worry to free the memory allocated to the object when the object no more required. The java Garbage Collector Thread does this for the programmer, it sweeps out the unwanted object and frees up the memory by under the control of JVM. The programmer can also control when objects will be garbage collected when required by using the java.lang.ref classes. There are four types of references in java based on the ways they are garbage collected or based on the behavior of the Garbage Collector behave on the references.
Types of Java References with Examples
There are four types of java references based on the behavior of the Garbage Collector behave on the references.
- Strong References: This is the default reference in java. Strong references can be created when an object is defined regularly.
- Weak References: This reference is to be explicitly specified. The weak references can be created by using java.lang.ref.WeakReference class.
- Soft References: Soft references can be created by using lang.ref.SoftReference class.
- Phantom References: the phantom references can be created by using lang.ref.PhantomReference class.
1. Strong References
A strong reference is usually we use while we write the java code or we create an object. An object which has strong reference and active in the memory is not eligible for garbage collection, an object which has strongly referenced points to null can be garbage collected. For example, the below code snippet where variable ob is the object of the type ClassA.
ClassA ob = new ClassA();
An ‘ob’ object is having strong reference to which is pointing to class ClassA, this object can not be garbage collected because an ob is an active object.
If reference ‘ob’ point to null as below –
ob = null;
So now the object is not referencing to class ClassA and hence an object is eligible for garbage collection now.
Example
Code:
package p1;
class ClassA
{
// something
}
public class Demo {
public static void main( String[] arg )
{
ClassA ob = new ClassA(); // default reference or Strong Reference
System.out.println(ob);
ob = null; // Now object ob pointing to null and is available for garbage collection
System.out.println(ob);
}
}
4.5 (143 ratings)
View Course
Output:
2. Weak References
The weak reference is eligible for garbage collection. Once JVM detects an object with weak reference then this object marked and garbage collected when garbage collector thread runs by JVM. These types of references used in WeakHashMap for the object’s entry. The weak references can be created by class lang.ref.WeakReference. The weak reference can be used in an application were to establish DBConnection and once the database closed the connection free by Garbage Collector. For example, the below code snippet where variable ob is the object of the type ClassA.
ClassA ob = new ClassA();
An ‘ob’ object is a strong reference to make it garbage collectible we need to convert its reverence to weak reference as below –
WeakReference<ClassA> weakob = new WeakReference<ClassA>(ob);
So now the object is weak referencing to class ClassA and hence an object is now available for garbage collection and it is garbage collected when JVM run garbage collection thread.
Example
Code:
package p1;
import java.lang.ref.WeakReference;
class ClassA
{
// something
}
public class Demo {
public static void main( String[] arg )
{
ClassA ob = new ClassA(); // default reference or Strong Reference
System.out.println(ob);
// now create Weak Reference object to which ob object is pointing
WeakReference <ClassA> weakob = new WeakReference <ClassA>(ob);
// Now ob object is eligible for garbage collection, but it will be remove from memory when JVM needs memory
ob = null;
System.out.println(ob);
// weakly referenced ob object can get back
ob = weakob.get();
System.out.println(ob);
}
}
Output:
3. Soft References
The object of soft reference is not eligible for garbage collection until JVM runs out of memory or JVM badly needs memory. The weak references can be created by class lang.ref.SoftReference. For example, the soft reference can create Similarly to weak reference.
SoftReference <ClassA> softob = new SoftReference <ClassA>(ob);
Example
Code:
package p1;
import java.lang.ref.SoftReference;
class ClassA
{
// something
}
public class Demo {
public static void main( String[] arg )
{
ClassA ob = new ClassA();// default reference or Strong Reference
System.out.println(ob);
// now create soft Reference object which ob object is pointing
SoftReference <ClassA> softob = new SoftReference <ClassA>(ob);
// Now ob object is eligible for garbage collection, but it will be garbage collected when JVM badly needs memory
ob = null;
System.out.println(ob);
// the soft referenced, ob object can get back
ob = softob.get();
System.out.println(ob);
}
}
Output:
4. Phantom References
An object of phantom reference is available for garbage collection, but before garbage collecting it, an object is put in a reference queue named as ‘reference queue’ by the JVM after finalize() function call on the object. The weak references can be created by class lang.ref. PhantomReference.
Example
Code:
package p1;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.PhantomReference;
class ClassA
{
// something
}
public class Demo {
public static void main( String[] arg )
{
ClassA ob = new ClassA(); // default reference or Strong Reference
System.out.println(ob);
// now Create Reference queue object
ReferenceQueue <ClassA> refq = new ReferenceQueue <ClassA>();
// Create Phantom Reference object to which ob object is pointing
PhantomReference <ClassA> phantomob = new PhantomReference <ClassA>(ob,refq);
// Now ob object is eligible for garbage collection, but it will be kept in 'refq' before removing
ob = null;
System.out.println(ob);
// to get back object which has been Phantom referenced returns null
ob = phantomob.get();
System.out.println(ob);
}
}
Output:
Recommended Articles
This is a guide to Java References. Here we also discuss the Introduction and types of java references along with different examples and its code implementation. You may also have a look at the following articles to learn more –
