Quais são os tipos de referências em Java e quais são as suas características?

Em Java, existem três tipos principais de referências (variáveis de referência), que diferem no comportamento do recolhedor de lixo:

• Referência Forte (Strong Reference)
• Referência Suave (Soft Reference)
• Referência Fraca (Weak Reference)
• Referência Fantasma (Phantom Reference)

Referência Forte (Strong Reference)

Este é o tipo de referência mais comum. Um objeto apontado por uma referência forte não será recolhido pelo recolhedor de lixo enquanto existir pelo menos uma referência forte a ele.

// Criação de um objeto e uma referência forte a ele
Object myObject = new Object(); 

Referência Suave (Soft Reference)

Uma referência suave aponta para um objeto que pode ser recolhido pelo recolhedor de lixo se a JVM precisar de memória. Os objetos apontados apenas por referências suaves não serão garantidamente recolhidos até que a JVM tenha uma necessidade urgente de libertar memória. Usado frequentemente para cache.

import java.lang.ref.SoftReference;

// Criação de um objeto
Object data = new Object(); 
// Criação de uma referência suave ao objeto
SoftReference<Object> softRef = new SoftReference<>(data); 

// O objeto data pode ser recolhido se a memória faltar
// Se o objeto não tiver sido recolhido, pode ser recuperado
Object retrievedData = softRef.get(); 

Referência Fraca (Weak Reference)

Uma referência fraca aponta para um objeto que pode ser recolhido pelo recolhedor de lixo a qualquer momento se não houver referências fortes a ele. As referências fracas são frequentemente usadas para implementar caches, onde os elementos podem ser descartados em caso de falta de memória.

import java.lang.ref.WeakReference;

// Criação de um objeto
Object cacheEntry = new Object(); 
// Criação de uma referência fraca ao objeto
WeakReference<Object> weakRef = new WeakReference<>(cacheEntry); 

// O objeto cacheEntry pode ser recolhido a qualquer momento
// Verificação se o objeto foi recolhido
if (weakRef.get() == null) { 
    // O objeto foi recolhido
}

Referência Fantasma (Phantom Reference)

Uma referência fantasma é usada em conjunto com ReferenceQueue para realizar ações antes de o objeto ser completamente eliminado da memória. Não é possível obter o objeto através de uma referência fantasma (get() sempre devolve null). Usado principalmente para gestão de recursos que requerem limpeza especial.

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

// Criação de um objeto para rastreamento
Object resource = new Object(); 
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>(); 
// Criação de uma referência fantasma e ligação com a fila
PhantomReference<Object> phantomRef = new PhantomReference<>(resource, referenceQueue); 

// Num thread separado, pode-se monitorizar a fila referenceQueue
// Quando o objeto resource estiver pronto para ser eliminado, a referência fantasma aparecerá na fila

Características e comparação:

Tipo de referência	Recolhedor de lixo	Obter objeto com get()	Uso
Referência Forte	Não recolhe	Sim	Uso comum
Referência Suave	Pode recolher	Sim (se não recolhido)	Caching (quando há falta de memória)
Referência Fraca	Pode recolher	Sim (se não recolhido)	Caching (se não há referências fortes)
Referência Fantasma	Pode recolher	Não (sempre null)	Limpeza de recursos antes de eliminar (com ReferenceQueue)