Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Ciclo de vida das referências fracas, suaves e fantasma em Java

Aprende quando uma referência devolve o seu referente, o que entra na fila e como `reachabilityFence` mantém um objeto fortemente alcançável.

Versão: Java SE 21

Sintaxe

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

Em java.lang.ref (módulo java.base), a referência e o objeto para o qual aponta, chamado referente, são objetos distintos. Quando o coletor de lixo (GC) deteta que um objeto é fracamente alcançável, ou seja, que não é alcançável de forma forte nem suave, mas que pode ser alcançado através de uma referência fraca, limpa as suas WeakReference. Em resposta às necessidades de memória, o GC pode limpar, ao seu critério, as SoftReference para objetos alcançáveis de forma suave. A máquina virtual garante que todas essas referências suaves são limpas antes de lançar OutOfMemoryError, mas não fixa de outro modo o momento nem a ordem. PhantomReference serve para notificações de limpeza: o GC limpa-a ao detetar alcançabilidade fantasma e o seu get() devolve sempre null.

Os construtores de referências fracas e suaves aceitam apenas o referente ou o referente com uma ReferenceQueue<? super T>. O construtor fantasma exige sempre um argumento para a fila. Passar null como fila significa não registar a referência. Numa referência fraca ou suave, get() devolve o referente ou null se estiver ausente, por exemplo após a limpeza. Lê o resultado uma vez, verifica que não é null e usa a mesma variável local. clear() desfaz a ligação, mas por si só não coloca a referência na fila nem liberta o referente. enqueue() limpa a referência e tenta adicioná-la explicitamente à fila em que foi registada; devolve true se o conseguir.

O método estático Reference.reachabilityFence(obj) mantém obj fortemente alcançável até ao fim da chamada, mesmo que o código já não o use diretamente. Coloca a chamada num bloco finally depois da operação que precisa que o objeto continue vivo, para que seja executada também em caso de exceção. Passa o próprio objeto, não a referência fraca, suave ou fantasma que o envolve. O método não desencadeia o GC nem a finalização; com null não tem efeito.

De uma ReferenceQueue<T> retira-se um Reference<? extends T>, não o seu referente. poll() retira e devolve uma referência disponível ou devolve null imediatamente. remove() espera sem limite. Com um tempo positivo em milissegundos, remove(long timeout) devolve null quando o tempo expira, sem garantias de tempo real. 0 indica espera sem limite; um valor negativo lança IllegalArgumentException. Ambas as sobrecargas de remove lançam InterruptedException se a espera for interrompida.

O GC coloca as referências registadas na fila ao limpá-las ou mais tarde; o momento não é previsível. Um poll() sem resultado não significa que o referente ainda esteja vivo. Mantém uma referência forte para cada objeto referência registado enquanto precisares da notificação: o registo por si só não o mantém vivo. Não dependas de notificações do GC para fechar recursos a tempo.

Exemplos

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

A barreira mantém `target` fortemente alcançável e `enqueue()` adiciona explicitamente uma entrada antes de cada `remove`. O exemplo distingue limpeza de colocação na fila; não mostra quando atua o GC nem a expiração do tempo de espera.

Lições relacionadas

  • Java · Lição 45 · Avançado · Versão: 2

Fontes