Diferencias entre referencias débiles, suaves, fantasmas y regulares en Java

Las referencias "débiles" y las referencias "blandas" (WeakReference, SoftReference) se agregaron a la API de Java hace mucho tiempo, pero no todos los programadores están familiarizados con ellas. Esto indica una brecha en la comprensión de dónde y cómo usarlos. Las clases de referencia son especialmente importantes en el contexto de la recolección de basura . Como todos sabemos, el propio recolector de basura libera la memoria ocupada por los objetos, pero no todos los programadores saben que toma la decisión de liberar memoria en función del tipo de referencias disponibles para el objeto. La principal diferencia entre SoftReference y WeakReference es cómo trabajará el recopilador con ellos. Puede eliminar un objeto en cualquier momento si solo los enlaces débiles apuntan a él; por otro lado, los objetos con un enlace suave se recopilarán solo cuando la JVM realmente necesite memoria. Debido a estas características de las clases de referencia, cada una de ellas tiene su propio uso. SoftReference se puede utilizar para implementar cachés y cuando la JVM necesite memoria la liberará eliminando dichos objetos. Y las WeakReferences son excelentes para almacenar metadatos, por ejemplo, almacenar un enlace a un ClassLoader. Si no hay clases para cargar, entonces no tiene sentido almacenar una referencia al ClassLoader ; una referencia débil hace que el ClassLoader esté disponible para su eliminación tan pronto como lo asignamos en lugar de una referencia fuerte. En este artículo veremos las diferencias entre los tipos de enlaces, incluida la referencia fuerte y la referencia fantasma .

WeakReference vs SoftReference en Java

Para quien no lo sepa, existen 4 tipos de enlaces:

1. Fuerte referencia
2. Referencia débil
3. referencia suave
4. Referencia fantasma

El vínculo fuerte es el más simple, ya que lo usamos en programación todos los días, por ejemplo, en código como String s = “abc” la variable s es el vínculo fuerte. El recolector de basura prohíbe eliminar cualquier objeto que tenga una referencia fuerte. Por supuesto, estos son objetos que el programa Java necesita. Las referencias débiles están representadas por la clase java.lang.ref.WeakReference . Puede definir una referencia débil como esta:

Counter counter = new Counter(); // strong reference
WeakReference weakCounter = new WeakReference(counter); //weak reference
counter = null; // now Counter object is eligible for garbage collection

Ahora, una vez que establece el contador de referencia fuerte en nulo (contador = nulo), el objeto creado en la primera línea pasa a estar disponible para la recolección de basura porque ya no tiene una referencia fuerte. La referencia débilCounter creada por Weak no puede evitar que el recopilador elimine el objeto Counter. Por otro lado, si fuera una referencia suave, el objeto Counter no se eliminaría hasta que la JVM tuviera una necesidad de memoria particularmente alta. Las referencias suaves en Java están representadas por la clase java.lang.ref.SoftReference . Ejemplo de creación de una SoftReference en Java

Counter prime = new Counter();  // prime holds a strong reference
SoftReference soft = new SoftReference(prime) ; //soft reference variable has SoftReference to Counter Object
prime = null;  // now Counter object is eligible for garbage collection but only be collected when JVM absolutely needs memory

Después de borrar la referencia fuerte (en la tercera línea), solo quedará 1 referencia suave en el objeto Contador, lo que no podrá evitar que el recolector de basura elimine este objeto, pero a diferencia de una referencia débil, podrá posponer este proceso hasta que haya una grave escasez de memoria. Dada esta diferencia entre enlaces blandos y enlaces débiles, el primero es más adecuado para cachés y el débil para metadatos. Un buen ejemplo es la clase WeakHashMap, que es descendiente de la interfaz Map como las clases HashMap o TreeMap , pero con una característica distintiva. WeakHashMap envuelve las claves como referencias débiles, lo que significa que tan pronto como no haya referencias fuertes a un objeto, las referencias débiles ubicadas dentro de WeakHashMap no lo salvarán del recolector de basura. Los enlaces fantasma son el tercer tipo de enlaces disponibles en el paquete java.lang.ref. Las referencias fantasma están representadas por la clase java.lang.ref.PhantomReference . El recopilador puede eliminar un objeto al que solo se accede mediante enlaces fantasmas en cualquier momento. Un enlace fantasma se crea de la misma manera que un enlace débil o blando.

DigitalCounter digit = new DigitalCounter(); // digit reference variable has strong reference
PhantomReference phantom = new PhantomReference(digit); // phantom reference
digit = null;

Una vez que borre las referencias fuertes al objeto DigitalCounter, el recolector de basura lo eliminará en cualquier momento, ya que ahora solo las referencias fantasmas apuntan a él. Además de las clases WeakReference, SoftReference, PhantomReference, WeakHashMap, es útil conocer la clase ReferenceQueue . Puede utilizar esta clase al crear un objeto WeakReference, SoftReference o PhantomReference:

ReferenceQueue refQueue = new ReferenceQueue(); //reference will be stored in this queue for cleanup
DigitalCounter digit = new DigitalCounter();
PhantomReference phantom = new PhantomReference(digit, refQueue);

La referencia del objeto se agregará a ReferenceQueue y podrá monitorear el estado de las referencias sondeando ReferenceQueue. El ciclo de vida de Object está bien representado en este diagrama: esas son todas las diferencias entre referencias débiles y suaves en Java . También nos familiarizamos con los enlaces fantasma, la clase WeakHashMap y ReferenceQueue . El uso correcto de referencias ayudará con la recolección de basura y dará como resultado una administración de memoria más flexible en Java . Artículo original