Referência fraca
http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/ref/WeakReference.html
Princípio: weak reference está relacionado à coleta de lixo. Normalmente, objeto com um ou maisreference não será elegível para coleta de lixo.
O princípio acima não é aplicável quando é weak reference. Se um objeto tiver apenas uma referência fraca com outros objetos, estará pronto para a coleta de lixo.
Vejamos o exemplo abaixo: Temos um Map com objetos onde Key é referência a um objeto.
import java.util.HashMap;
public class Test {
public static void main(String args[]) {
HashMap<Employee, EmployeeVal> aMap = new
HashMap<Employee, EmployeeVal>();
Employee emp = new Employee("Vinoth");
EmployeeVal val = new EmployeeVal("Programmer");
aMap.put(emp, val);
emp = null;
System.gc();
System.out.println("Size of Map" + aMap.size());
}
}
Agora, durante a execução do programa que fizemos emp = null . A Maprealização a chave não faz sentido aqui como é null. Na situação acima, o objeto não é coletado como lixo.
WeakHashMap
WeakHashMap é aquele em que as entradas (key-to-value mappings ) serão removidas quando não for mais possível recuperá-las do Map.
Deixe-me mostrar o exemplo acima mesmo com o WeakHashMap
import java.util.WeakHashMap;
public class Test {
public static void main(String args[]) {
WeakHashMap<Employee, EmployeeVal> aMap =
new WeakHashMap<Employee, EmployeeVal>();
Employee emp = new Employee("Vinoth");
EmployeeVal val = new EmployeeVal("Programmer");
aMap.put(emp, val);
emp = null;
System.gc();
int count = 0;
while (0 != aMap.size()) {
++count;
System.gc();
}
System.out.println("Took " + count
+ " calls to System.gc() to result in weakHashMap size of : "
+ aMap.size());
}
}
Saída: levou 20 calls to System.gc()para resultar emaMap size : 0.
WeakHashMaptem apenas referências fracas às chaves, não referências fortes como outras Mapclasses. Há situações em que você deve tomar cuidado quando o valor ou a chave é fortemente referenciado, embora você tenha usado WeakHashMap. Isso pode ser evitado envolvendo o objeto em um WeakReference .
import java.lang.ref.WeakReference;
import java.util.HashMap;
public class Test {
public static void main(String args[]) {
HashMap<Employee, EmployeeVal> map =
new HashMap<Employee, EmployeeVal>();
WeakReference<HashMap<Employee, EmployeeVal>> aMap =
new WeakReference<HashMap<Employee, EmployeeVal>>(
map);
map = null;
while (null != aMap.get()) {
aMap.get().put(new Employee("Vinoth"),
new EmployeeVal("Programmer"));
System.out.println("Size of aMap " + aMap.get().size());
System.gc();
}
System.out.println("Its garbage collected");
}
}
Referências suaves.
Soft Referenceé um pouco mais forte que a referência fraca. A referência suave permite a coleta de lixo, mas pede ao coletor de lixo que a limpe apenas se não houver outra opção.
O coletor de lixo não coleta agressivamente objetos de fácil acesso, como ocorre com objetos de fácil acesso - em vez disso, apenas coleta objetos de fácil acesso se realmente "precisar" da memória. Referências suaves são uma maneira de dizer ao coletor de lixo: "Enquanto a memória não estiver muito tensa, eu gostaria de manter esse objeto por perto. Mas se a memória ficar muito tensa, vá em frente e colete-a, e eu resolvo com isso." O coletor de lixo é necessário para limpar todas as referências suaves antes que ele possa ser lançado OutOfMemoryError.