Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Ciclo di vita dei riferimenti deboli, soft e fantasma in Java

Scopri quando un riferimento restituisce il suo oggetto, cosa entra nella coda e come `reachabilityFence` mantiene un oggetto fortemente raggiungibile.

Versione: Java SE 21

Sintassi

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

In java.lang.ref (modulo java.base), il riferimento e l’oggetto a cui punta, detto referente, sono oggetti distinti. Quando il garbage collector (GC) rileva che un oggetto è debolmente raggiungibile, cioè che non è raggiungibile né in modo forte né in modo soft ma può essere raggiunto passando per un riferimento debole, azzera i suoi WeakReference. Il GC può azzerare a sua discrezione i SoftReference agli oggetti raggiungibili in modo soft, in risposta al fabbisogno di memoria. La VM garantisce che tutti questi riferimenti soft vengano azzerati prima di lanciare OutOfMemoryError, ma non stabilisce altrimenti tempi o ordine. PhantomReference serve per le notifiche di pulizia: il GC lo azzera quando rileva la raggiungibilità fantasma e il suo get() restituisce sempre null.

I costruttori dei riferimenti deboli e soft accettano il solo referente oppure il referente e una ReferenceQueue<? super T>. Il costruttore del riferimento fantasma richiede sempre l’argomento della coda; passare null significa non registrare il riferimento. Su un riferimento debole o soft, get() restituisce il referente oppure null se manca, ad esempio dopo l’azzeramento. Leggi il risultato una volta, controlla che non sia null e usa la stessa variabile locale. clear() spezza il collegamento, ma da solo non accoda il riferimento né libera il referente. enqueue() azzera il riferimento e tenta di inserirlo esplicitamente nella coda di registrazione; restituisce true se l’inserimento riesce.

Il metodo statico Reference.reachabilityFence(obj) mantiene obj fortemente raggiungibile fino al termine della chiamata, anche se il codice ha già smesso di usarlo direttamente. Colloca la chiamata in un blocco finally dopo l’operazione che richiede che l’oggetto rimanga in vita, così verrà eseguita anche in caso di eccezione. Passa l’oggetto stesso, non il riferimento debole, soft o fantasma che lo contiene. Il metodo non avvia il GC né la finalizzazione; con null non ha effetto.

Da una ReferenceQueue<T> si estrae un Reference<? extends T>, non il suo referente. poll() estrae un riferimento disponibile o restituisce subito null. remove() attende senza limiti. Con un tempo positivo in millisecondi, remove(long timeout) restituisce null alla scadenza, senza garanzie di tempo reale. 0 indica un’attesa illimitata; un valore negativo causa IllegalArgumentException. Entrambi gli overload di remove lanciano InterruptedException se l’attesa viene interrotta.

Il GC accoda i riferimenti registrati al momento dell’azzeramento o più tardi; il momento non è prevedibile. Un poll() senza risultati non significa che il referente sia ancora in vita. Mantieni un riferimento forte a ogni oggetto riferimento registrato finché ti serve la notifica: la registrazione da sola non lo mantiene in vita. Non affidarti alle notifiche del GC per chiudere le risorse in tempo.

Esempi

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);
        }
    }
}

Risultato

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 barriera mantiene `target` fortemente raggiungibile e `enqueue()` inserisce esplicitamente un elemento prima di ogni `remove`. L’esempio distingue azzeramento e accodamento; non dimostra i tempi del GC né la scadenza dell’attesa.

Lezioni correlate

  • Java · Lezione 45 · Avanzato · Versione: 2

Fonti