Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Cycle de vie des références faibles, souples et fantômes en Java

Découvrez quand une référence rend son objet accessible, ce qui entre dans la file et comment `reachabilityFence` maintient l’accessibilité forte.

Version : Java SE 21

Syntaxe

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

Dans java.lang.ref (module java.base), l’objet référence est distinct de l’objet qu’il désigne, appelé référent. Quand le ramasse-miettes (GC) détecte qu’un référent est faiblement accessible, c’est-à-dire qu’il n’est ni fortement ni souplement accessible, mais qu’on peut l’atteindre en suivant une référence faible, il efface ses WeakReference. En fonction des besoins de mémoire, le GC peut effacer à sa discrétion les SoftReference vers les objets souplement accessibles. La VM garantit que toutes ces références souples sont effacées avant de lancer OutOfMemoryError, sans fixer autrement de délai ni d’ordre. PhantomReference sert aux notifications de nettoyage : le GC l’efface lorsqu’il détecte l’accessibilité fantôme et son get() renvoie toujours null.

Les constructeurs des références faibles et souples prennent le référent seul ou avec une ReferenceQueue<? super T>. Le constructeur fantôme exige toujours un argument pour la file ; passer null signifie qu’il n’y a pas d’inscription. Sur une référence faible ou souple, get() renvoie le référent ou null s’il est absent, par exemple après un effacement. Lisez le résultat une seule fois, vérifiez qu’il n’est pas null, puis réutilisez la même variable locale. clear() supprime le lien, mais ne met pas la référence en file et ne libère pas le référent. enqueue() efface la référence et tente de l’ajouter explicitement à sa file d’inscription ; l’ajout réussi renvoie true.

La méthode statique Reference.reachabilityFence(obj) maintient obj fortement accessible jusqu’à la fin de l’appel, même si le code a cessé de l’utiliser directement. Placez cet appel dans un finally, après l’opération qui a besoin que l’objet reste vivant, pour qu’il s’exécute aussi en cas d’exception. Passez l’objet lui-même et non son enveloppe faible, souple ou fantôme. Cette méthode ne déclenche ni le GC ni la finalisation ; avec null, elle est sans effet.

Une ReferenceQueue<T> fournit un objet Reference<? extends T>, pas son référent. poll() retire et renvoie une référence disponible, ou renvoie immédiatement null. remove() attend sans limite de durée. Avec un délai positif en millisecondes, remove(long timeout) renvoie null à l’expiration, sans garantie temps réel. 0 signifie une attente sans limite ; une valeur négative déclenche IllegalArgumentException. Les deux surcharges de remove lancent InterruptedException si l’attente est interrompue.

Le GC met les références inscrites en file au moment de l’effacement ou plus tard, à un moment imprévisible. Un poll() sans résultat ne signifie pas que le référent est encore vivant. Conservez une référence forte vers chaque objet référence inscrit tant que sa notification vous intéresse : l’inscription seule ne le maintient pas en vie. Ne comptez pas sur les notifications du GC pour fermer vos ressources à temps.

Exemples

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

Résultat

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 barrière maintient `target` fortement accessible et `enqueue()` ajoute explicitement une entrée avant chaque `remove`. L’exemple distingue l’effacement de la mise en file ; il ne mesure ni le délai du GC ni l’expiration du délai d’attente.

Leçons associées

  • Java · Leçon 45 · Avancé · Version : 2

Sources