Référence faible
http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/ref/WeakReference.html
Principe: weak reference est lié à la collecte des ordures. Normalement, un objet en ayant un ou plusieurs referencene sera pas éligible pour la récupération de place.
Le principe ci-dessus n'est pas applicable lorsqu'il l'est weak reference. Si un objet n'a qu'une référence faible avec d'autres objets, il est prêt pour la collecte des ordures.
Regardons l'exemple ci-dessous: Nous avons un Mapavec des objets où Key fait référence à un objet.
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());
}
}
Maintenant, pendant l'exécution du programme que nous avons fait emp = null. La Maptenue la clé n'a pas de sens ici comme il est null. Dans la situation ci-dessus, l'objet n'est pas récupéré.
WeakHashMap
WeakHashMapest celui où les entrées ( key-to-value mappings) seront supprimées lorsqu'il ne sera plus possible de les récupérer à partir du Map.
Permettez-moi de montrer l'exemple ci-dessus avec 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());
}
}
Sortie: a pris 20 calls to System.gc()pour résultat aMap size: 0.
WeakHashMapn'a que des références faibles aux clés, pas des références fortes comme les autres Mapclasses. Il y a des situations auxquelles vous devez faire attention lorsque la valeur ou la clé est fortement référencée bien que vous l'ayez utilisée WeakHashMap. Cela peut être évité en enveloppant l'objet dans une référence faible .
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");
}
}
Références souples.
Soft Referenceest légèrement plus fort que la référence faible. La référence logicielle permet le ramasse-miettes, mais demande au ramasse-miettes de l'effacer uniquement s'il n'y a pas d'autre option.
Le ramasse-miettes ne collecte pas de manière agressive les objets facilement accessibles comme il le fait avec les objets peu accessibles - au lieu de cela, il ne collecte les objets facilement accessibles que s'il "a vraiment besoin" de la mémoire. Les références souples sont une façon de dire au garbage collector: "Tant que la mémoire n'est pas trop serrée, je voudrais garder cet objet autour. Mais si la mémoire devient vraiment serrée, allez-y et récupérez-la et je traiterai avec ça." Le garbage collector est nécessaire pour effacer toutes les références logicielles avant de pouvoir lancer OutOfMemoryError.