Clase java.lang.ref.SoftReference en Java

Cuando creamos un objeto en Java, un objeto no es suave por defecto. Para crear un objeto de referencia suave, debemos especificarlo explícitamente en la JVM . En la referencia suave, incluso si el objeto está libre para la recolección de basura, entonces tampoco se recolecta la basura hasta que JVM necesita memoria. Los objetos se borran de la memoria cuando JVM se queda sin memoria.

¿Por qué se utilizan objetos de referencia suave?

Cuando se crea un objeto de referencia suave, se marca para la recolección de elementos no utilizados. Sin embargo, no se recolecta basura hasta que ya menos que haya una deficiencia de memoria en la JVM.

Constructores en la clase SoftReference:

método get():

// Java program to show the demonstration
// of get() method of SoftReference Class
 
import java.lang.ref.SoftReference;
class GFG {
    public static void main (String[] args) {
       
        // creating a strong object of MyClass
          MyClass obj = new MyClass ();
       
          // creating a weak reference of type MyClass
          SoftReference<MyClass> sobj = new SoftReference<>(obj);
       
          System.out.println ("-> Calling Display Function using strong object:");
          obj.Display ();   
       
          System.out.println ("-> Object set to null");
       
          obj = null;
       
        // Calling the get() method
          obj = sobj.get();
          System.out.println ("-> Calling Display Function after retrieving from soft Object");
          obj.Display ();
    }
}
class MyClass {
      void Display ()
    {
        System.out.println ("Display Function invoked ...");
    }
}

-> Calling Display Function using strong object:
Display Function invoked ...
-> Object set to null
-> Calling Display Function after retrieving from soft Object
Display Function invoked ...

Ejemplo que muestra el método enqueue() y isEnqueued() de la clase SoftReference:

// Java program demonstrating all the methods
// of SoftRefernce Class
 
import java.lang.ref.SoftReference;
class GFG {
    public static void main (String [] args) {
      
        // Creating object of Class X
        X obj = new X ();
       
        // Creating a soft reference of type X
          SoftReference <X> softobj = new SoftReference <X> (obj);
       
          System.out.println ("-> Retrieving object from Soft Reference using get ()");
          softobj.get().show();
       
          System.out.println ("-> Is it possible to queue object using enqueue ()");
          System.out.println (softobj.enqueue ());
       
          System.out.println ("-> Checking if reference is queued using isEnqueued ()");
          System.out.println (softobj.isEnqueued ());
    }
}
class X {
    void show()
    {
        System.out.println ("show () from X invoked..");
    }
}

-> Retrieving object from Soft Reference using get()
show() from X invoked..
-> Is it possible to queue object using enqueue()
false
-> Checking if reference is queued using isEnqueued()
false

Métodos heredados de la clase de referencia: