En los lenguajes de programación orientados a objetos con recolección de basura, la resurrección de objetos es cuando un objeto vuelve a la vida durante el proceso de destrucción de objetos, como efecto secundario de la ejecución de un finalizador.
La resurrección de objetos causa una serie de problemas, particularmente que la posibilidad de resurrección de objetos incluso si no ocurre hace que la recolección de elementos no utilizados sea significativamente más complicada y lenta, y es una de las principales razones por las que se desaconsejan los finalizadores. Los lenguajes se ocupan de la resurrección de los objetos de varias maneras, como soluciones a estos problemas. En raras circunstancias, la resurrección de objetos se usa para implementar ciertos patrones de diseño, en particular, un grupo de objetos, mientras que en otras circunstancias, la resurrección es un error no deseado causado por un error en los finalizadores y, en general, se desaconseja la resurrección.
Un objeto se convierte en basura cuando ya no es accesible desde el programa y puede ser recolectado (destruido y reasignado). Luego, durante la destrucción del objeto, antes de que el recolector de basura desasigne el objeto, se puede ejecutar el método finalize, que puede, a su vez, hacer que el objeto basura sea accesible nuevamente creando referencias a él.
Si posteriormente se elimina la referencia de un objeto resucitado, vuelve a ser elegible para la recolección de elementos no utilizados. Sin embargo, esta vez el método finalize() no se volverá a invocar, ya que Java solo invoca el finalizador como máximo una vez. En la última mitad, la salida se ilustra con la ayuda de una ilustración de video de cómo la salida se retiene en la pantalla para que se entienda claramente.
Ejemplo:
Java
// Java Program to illustrate Object Resurrection
// Importing all utility classes from java.util package
// Importing all input output classes from java.io package
import java.io.*;
import java.util.*;
// Main class
public class GFG {
// Member variable of this class
private int num;
// Constructor of the class
public GFG(int num)
{
// This keyword refers to current instance
this.num = num;
}
// Creating an ArrayList class object
// Declaring object of class type
static final ArrayList<GFG> ar = new ArrayList<GFG>();
// Method 1 (protected)
protected void finalize() throws Throwable
{
System.out.println("Resurrect " + num);
// Adding the current instance to object
// using this operator
ar.add(this);
}
// Method 2
// Standard way to convert to string type
public String toString()
{
return "Element{"
+ "num=" + num + '}';
}
// Method 3
// Main driver method
public static void main(String[] args)
throws InterruptedException
{
// Iterating using nested for loops
for (int i = 0; i < 3; i++)
ar.add(new GFG(i));
for (int j = 0; j < 5; j++) {
// print the element in the object
System.out.println("Elements : " + ar);
// Clearing off elements using clear() method
ar.clear();
// Garbage collector
System.gc();
// Making the thread to sleep for a 1/10 sec
// using the sleep() method
Thread.sleep(500);
}
}
}
Producción :
Elements : [Element{num=0}, Element{num=1}, Element{num=2}]
Resurrect 2
Resurrect 1
Resurrect 0
Elements : [Element{num=2}, Element{num=1}, Element{num=0}]
Elements : []
Elements : []
Elements : []
Salida Explicación:
Los elementos se agregan una vez a la colección y se resucitan una vez mediante el método de finalización. Cuando se recopilan por segunda vez, se marcan como finalizados y no se vuelven a poner en cola. Se demuestra con la ayuda de la salida de video.