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 no need to worry to free the object’s memory 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 Garbage Collector’s behaviour on the references.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Types of Java References with Examples

There are four types of java references based on the Garbage Collector’s behaviour 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 a 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;

Now the object is not referencing to class ClassA; 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 <u>ob</u> pointing to null and is available for garbage collection
System.out.println(ob);
}
}

Output:

2. Weak References

The weak reference is eligible for garbage collection. Once JVM detects an object with weak reference, this object is marked, and garbage is collected when the 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 that 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);</classa></classa>

Now the object is weak referencing to class ClassA, an object is now available for garbage collection, and it is garbage collected when JVM runs 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 <u>ob</u> object is pointing
WeakReference <classa> weakob = new WeakReference <classa>(ob);
// Now <u>ob</u> 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 <u>ob</u> object can get back
ob = weakob.get();
System.out.println(ob);
}
}</classa></classa>

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);</classa></classa>

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 <u>ob</u> 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, <u>ob</u> object can get back
ob = softob.get();
System.out.println(ob);
}
}</classa></classa>

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 <u>ob</u> object is pointing
PhantomReference <classa> phantomob = new PhantomReference <classa>(ob,refq);
// Now <u>ob</u> object is eligible for garbage collection, but it will be kept in '<u>refq</u>' 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);
}
}</classa></classa></classa></classa>

Output:

The above is the detailed content of Java References. For more information, please follow other related articles on the PHP Chinese website!