Referência Fraca

"Olá de novo!"

"Agora vou falar sobre mais uma coisa maravilhosa: WeakReference ."

"Parece quase o mesmo que SoftReference:"

// Create a Cat object
Cat cat = new Cat();

// Create a weak reference to a Cat object
WeakReference<Cat> catRef = new WeakReference<Cat>(cat);

// Now only the catRef weak reference points at the object
cat = null;

// Now the ordinary cat variable also references the object
cat = catRef.get();

// Clear the weak reference
catRef.clear();

"Uma referência fraca tem outra característica especial."

"Se um objeto não tiver referências comuns ou suaves, mas apenas referências fracas, então o objeto está vivo, mas será destruído na próxima coleta de lixo."

"Você pode dizer isso de novo? Qual é a diferença entre essas referências?"

"Um objeto protegido da morte apenas por um SoftReference pode sobreviver a quantas coletas de lixo você quiser e provavelmente será destruído se não houver memória suficiente."

"Um objeto salvo da morte apenas por um WeakReference não sobreviverá à próxima coleta de lixo. Mas até que isso aconteça, você pode obter o objeto chamando o método get() no WeakReference e, em seguida, chamar seus métodos ou fazer outra coisa com ele ."

"E se o objeto for referenciado por uma SoftReference e uma WeakReference?"

"Isso é simples. Se pelo menos uma referência regular apontar para um objeto, ele é considerado vivo. A propósito, essa referência é chamada de StrongReference."

"Se nenhuma referência regular apontar para um objeto, mas um SoftReference apontar, então ele é facilmente alcançável."

"Se nenhuma referência regular ou SoftReferences apontar para um objeto, mas um WeakReference apontar, então ele é fracamente alcançável."

"Pense nisso. Um SoftReference protege o objeto de ser excluído e garante que o objeto será excluído somente se houver memória insuficiente. Um WeakReference mantém o objeto até a próxima coleta de lixo. Um SoftReference oferece maior resistência à exclusão."

"Ah. Acho que entendi."

"Ótimo, então vou falar sobre outra coisa interessante envolvendo WeakReferences - o WeakHashMap."

"Parece sério!"

"E mais alguns! Um WeakHashMap é um HashMap cujas chaves são referências fracas (WeakReferences)."

"Ou seja, você adiciona objetos a tal HashMap e trabalha com eles. Negócios como de costume."

"Desde que os objetos que você armazena em um WeakHashMap tenham referências regulares (fortes ou suaves) como chaves, esses objetos estarão vivos."

"Mas suponha que não haja mais referências a esses objetos em todo o aplicativo. Tudo o que os impede de morrer são alguns WeakReferences dentro do WeakHashMap. Após a próxima coleta de lixo, esses objetos desaparecerão do WeakHashMap. Por si mesmos. Como se eles nunca estiveram lá."

"Não tenho certeza se entendi."

"Você armazena pares de objetos em um WeakHashMap: uma chave e um valor. Mas o WeakHashMap não faz referência às chaves diretamente, mas sim por meio de WeakReferences. Portanto, quando os objetos usados ​​como chaves tornam-se fracamente acessíveis, eles são destruídos na próxima coleta de lixo. E, como resultado, seus valores também são removidos automaticamente do WeakHashMap."

"É muito conveniente usar um WeakHashMap para armazenar informações adicionais sobre determinados objetos."

"Em primeiro lugar, acessar as informações é muito fácil se você usar o próprio objeto como chave."

"Em segundo lugar, se o objeto for destruído, ele desaparece do HashMap junto com todos os dados associados."

"Por exemplo:

// Create an object to store additional information about the user
WeakHashMap<User, StatisticInfo> userStatistics = new WeakHashMap<User, StatisticInfo>();

// Put information about the user into userStatistics
User user = session.getUser();
userStatistics.put(user, new StatisticInfo (…));

// Get information about the user from userStatistics
User user = session.getUser();
StatisticInfo statistics = userStatistics.get(user);

// Remove any information about the user from userStatistics
User user = session.getUser();
userStatistics.remove(user);

1. "Dentro de um WeakHashMap, as chaves são armazenadas como WeakReferences."
2. "Assim que o objeto do usuário é destruído pelo coletor de lixo, o método remove(user) é implicitamente chamado dentro do WeakHashMap e qualquer informação associada ao objeto do usuário é removida do WeakHashMap automaticamente."

"Parece uma ferramenta poderosa. Onde posso usá-la?"

"Isso depende das circunstâncias. Digamos que você tenha um thread no programa que rastreia o trabalho de algumas tarefas, representadas por objetos, e grava informações sobre eles em um log. Esse thread pode armazenar os objetos monitorados em um WeakHashMap. Assim que como os objetos não são necessários, o coletor de lixo os exclui e as referências a eles também são removidas automaticamente do WeakHashMap."

"Parece interessante. Já sinto que ainda não escrevi nenhum programa Java sério que aproveite esses mecanismos poderosos. Mas vou trabalhar para isso. Muito obrigado, Ellie, por uma lição tão interessante."