Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Ciclo de vida de las referencias débiles, blandas y fantasma en Java

Aprende cuándo una referencia devuelve su referente, qué entra en la cola y cómo `reachabilityFence` mantiene un objeto fuertemente alcanzable.

Versión: Java SE 21

Sintaxis

Java SE 21 · java.lang.ref (module java.base)
new WeakReference<T>(referent)
new WeakReference<T>(referent, queue)
new SoftReference<T>(referent)
new SoftReference<T>(referent, queue)
new PhantomReference<T>(referent, queue)
new ReferenceQueue<T>()

// Registered constructors accept ReferenceQueue<? super T>.
T value = reference.get();
reference.clear();
boolean added = reference.enqueue();
Reference.reachabilityFence(referent);

// For a queue of type ReferenceQueue<T>:
Reference<? extends T> ready = queue.poll();
Reference<? extends T> next = queue.remove(); // throws InterruptedException
Reference<? extends T> timed = queue.remove(timeoutMillis); // long; throws InterruptedException

En java.lang.ref (módulo java.base), la referencia y el objeto al que apunta, llamado referente, son objetos distintos. Cuando el recolector de basura (GC) detecta que un objeto es débilmente alcanzable, es decir, que no es alcanzable de forma fuerte ni blanda pero sí a través de una referencia débil, borra sus WeakReference. Según la demanda de memoria, el GC puede borrar a su criterio las SoftReference a objetos alcanzables de forma blanda. La máquina virtual garantiza que todas esas referencias blandas se borren antes de lanzar OutOfMemoryError, pero no fija por lo demás cuándo ni en qué orden. PhantomReference sirve para notificar tareas de limpieza: el GC la borra al detectar alcanzabilidad fantasma y su get() siempre devuelve null.

Los constructores de referencias débiles y blandas aceptan el referente solo o junto con una ReferenceQueue<? super T>. El constructor de la referencia fantasma siempre requiere el argumento de la cola. Pasar null como cola significa que no se registra. En una referencia débil o blanda, get() devuelve el referente o null si no lo hay, por ejemplo tras el borrado. Lee el resultado una sola vez, comprueba que no sea null y usa la misma variable local. clear() rompe el vínculo: no encola la referencia ni libera el referente por sí solo. enqueue() borra la referencia e intenta añadirla explícitamente a la cola en la que está registrada; devuelve true si lo consigue.

El método estático Reference.reachabilityFence(obj) mantiene obj fuertemente alcanzable hasta que termina la llamada, aunque el código ya no lo utilice directamente. Pon la llamada en un bloque finally después de la operación que necesita que el objeto siga vivo, para que también se ejecute si ocurre una excepción. Pasa el objeto, no la referencia débil, blanda o fantasma que lo envuelve. El método no dispara el GC ni la finalización; con null no tiene efecto.

Una ReferenceQueue<T> entrega un objeto Reference<? extends T>, no su referente. poll() retira y devuelve una referencia disponible o devuelve null de inmediato. remove() espera sin límite. Con un tiempo positivo en milisegundos, remove(long timeout) devuelve null al vencer el plazo, sin garantías de tiempo real. 0 indica espera sin límite y un valor negativo lanza IllegalArgumentException. Ambas sobrecargas de remove lanzan InterruptedException si se interrumpe la espera.

El GC encola las referencias registradas al borrarlas o más tarde; el momento no es predecible. Un poll() sin resultado no indica que el referente siga vivo. Conserva una referencia fuerte a cada objeto referencia registrado mientras necesites su notificación: el registro por sí solo no lo mantiene vivo. No dependas de notificaciones del GC para cerrar recursos a tiempo.

Ejemplos

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;

public class ReferenceLifecycle {
    public static void main(String[] args) throws InterruptedException {
        Object target = new Object();
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        WeakReference<Object> weak = new WeakReference<>(target, queue);
        SoftReference<Object> soft = new SoftReference<>(target);
        PhantomReference<Object> phantom = new PhantomReference<>(target, queue);

        try {
            System.out.println("weak.get() == target: " + (weak.get() == target));
            System.out.println("soft.get() == target: " + (soft.get() == target));
            weak.clear();
            soft.clear();
            System.out.println("weak.get() == null: " + (weak.get() == null));
            System.out.println("soft.get() == null: " + (soft.get() == null));
            System.out.println("poll() after clear: " + queue.poll());

            if (!weak.enqueue()) {
                throw new IllegalStateException("Expected weak reference to be enqueued");
            }
            System.out.println("remove(1000) == weak: " + (queue.remove(1000) == weak));

            System.out.println("phantom.get() == null: " + (phantom.get() == null));
            if (!phantom.enqueue()) {
                throw new IllegalStateException("Expected phantom reference to be enqueued");
            }
            System.out.println("remove() == phantom: " + (queue.remove() == phantom));
        } finally {
            Reference.reachabilityFence(target);
        }
    }
}

Resultado

weak.get() == target: true
soft.get() == target: true
weak.get() == null: true
soft.get() == null: true
poll() after clear: null
remove(1000) == weak: true
phantom.get() == null: true
remove() == phantom: true

La barrera mantiene `target` fuertemente alcanzable y `enqueue()` añade explícitamente una entrada antes de cada `remove`. El ejemplo distingue el borrado del encolado; no muestra cuándo actúa el GC ni el vencimiento del plazo.

Lecciones relacionadas

  • Java · Lección 45 · Avanzado · Versión: 2

Fuentes