Diferenças entre referências fracas, suaves, fantasmas e regulares em Java

Referências “fracas” e referências “soft” (WeakReference, SoftReference) foram adicionadas à API Java há muito tempo, mas nem todo programador está familiarizado com elas. Isso indica uma lacuna na compreensão de onde e como usá-los. As classes de referência são especialmente importantes no contexto da coleta de lixo . Como todos sabemos, o próprio coletor de lixo libera a memória ocupada pelos objetos, mas nem todos os programadores sabem que ele toma a decisão de liberar memória com base no tipo de referências disponíveis para o objeto. A principal diferença entre SoftReference e WeakReference é como o coletor trabalhará com eles. Ele pode excluir um objeto a qualquer momento se apenas links fracos apontarem para ele, por outro lado, objetos com link simbólico serão coletados apenas quando a JVM realmente precisar de memória. Devido a essas características das classes de referência, cada uma delas tem sua utilização. SoftReference pode ser usado para implementar caches e quando a JVM precisar de memória ela irá liberá-la excluindo tais objetos. E WeakReferences são ótimos para armazenar metadados, por exemplo, armazenar um link para um ClassLoader. Se não houver classes para carregar, então não faz sentido armazenar uma referência ao ClassLoader , uma referência fraca torna o ClassLoader disponível para remoção assim que o atribuímos em vez de uma referência Strong. Neste artigo veremos as diferenças entre os tipos de link, incluindo referência forte e referência fantasma .

WeakReference vs SoftReference em Java

Para quem não sabe, existem 4 tipos de links:

1. Referência forte
2. Referência Fraca
3. Referência suave
4. Referência Fantasma

O link forte é o mais simples, pois o utilizamos na programação todos os dias, por exemplo, em códigos como String s = “abc” a variável s é o link forte. Qualquer objeto que possua uma referência forte está proibido de ser removido pelo coletor de lixo. Claro, esses são objetos de que o programa Java precisa. Referências fracas são representadas pela classe java.lang.ref.WeakReference , você pode definir uma referência fraca como esta:

Counter counter = new Counter(); // strong reference
WeakReference weakCounter = new WeakReference(counter); //weak reference
counter = null; // now Counter object is eligible for garbage collection

Agora, depois de definir o contador de referência forte como nulo (contador = nulo), o objeto criado na primeira linha fica disponível para coleta de lixo porque não possui mais uma referência forte. A referência fracaCounter criada por Weak não pode impedir que o coletor exclua o objeto Counter. Por outro lado, se fosse uma referência Soft, o objeto Counter não seria excluído até que a JVM tivesse uma necessidade particularmente alta de memória. As referências suaves em Java são representadas pela classe java.lang.ref.SoftReference . Exemplo de criação de SoftReference em Java

Counter prime = new Counter();  // prime holds a strong reference
SoftReference soft = new SoftReference(prime) ; //soft reference variable has SoftReference to Counter Object
prime = null;  // now Counter object is eligible for garbage collection but only be collected when JVM absolutely needs memory

Após limpar a referência forte (na 3ª linha), apenas 1 referência suave permanecerá para o objeto Counter, o que não será capaz de impedir que o coletor de lixo exclua este objeto, mas ao contrário de uma referência fraca, poderá adiar esse processo até que haja uma escassez aguda de memória. Dada esta diferença entre links suaves e links fracos, o primeiro é mais adequado para caches e o fraco para metadados. Um bom exemplo é a classe WeakHashMap, que é descendente da interface Map como as classes HashMap ou TreeMap , mas com uma característica distintiva. WeakHashMap agrupa chaves como referências fracas, o que significa que, assim que não houver referências fortes a um objeto, as referências fracas localizadas dentro do WeakHashMap não o salvarão do coletor de lixo. Links fantasmas são o terceiro tipo de links disponíveis no pacote java.lang.ref. As referências fantasmas são representadas pela classe java.lang.ref.PhantomReference . Um objeto apontado apenas por links fantasmas pode ser excluído pelo coletor a qualquer momento. Um link fantasma é criado da mesma forma que um link fraco ou flexível.

DigitalCounter digit = new DigitalCounter(); // digit reference variable has strong reference
PhantomReference phantom = new PhantomReference(digit); // phantom reference
digit = null;

Depois de limpar as referências fortes ao objeto DigitalCounter, o coletor de lixo irá excluí-lo a qualquer momento, pois agora apenas as referências fantasmas apontam para ele. Além das classes WeakReference, SoftReference, PhantomReference, WeakHashMap, é útil conhecer a classe ReferenceQueue . Você pode usar esta classe ao criar um objeto WeakReference, SoftReference ou PhantomReference:

ReferenceQueue refQueue = new ReferenceQueue(); //reference will be stored in this queue for cleanup
DigitalCounter digit = new DigitalCounter();
PhantomReference phantom = new PhantomReference(digit, refQueue);

A referência do objeto será adicionada ao ReferenceQueue e você poderá monitorar o estado das referências pesquisando o ReferenceQueue. O ciclo de vida do Object está bem representado neste diagrama: Essas são todas as diferenças entre referências fracas e suaves em Java . Também conhecemos links fantasmas, a classe WeakHashMap e ReferenceQueue . O uso adequado de referências ajudará na coleta de lixo e resultará em um gerenciamento de memória mais flexível em Java . Artigo original