Riferimento debole
http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/ref/WeakReference.html
Principio: weak reference è legato alla raccolta dei rifiuti. Normalmente, l'oggetto con uno o più referencenon sarà idoneo per la garbage collection.
Il principio di cui sopra non è applicabile quando lo è weak reference. Se un oggetto ha solo un riferimento debole con altri oggetti, è pronto per la garbage collection.
Diamo un'occhiata all'esempio seguente: Abbiamo un oggetto Mapcon cui Chiave fa riferimento a un oggetto.
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());
}
}
Ora, durante l'esecuzione del programma, abbiamo realizzato emp = null. Tenere Mappremuto il tasto non ha senso qui com'è null. Nella situazione sopra, l'oggetto non viene raccolto.
WeakHashMap
WeakHashMapè uno in cui le voci ( key-to-value mappings) verranno rimosse quando non è più possibile recuperarle da Map.
Consentitemi di mostrare lo stesso esempio sopra con 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());
}
}
Uscita: Ha preso 20 calls to System.gc()a risultato aMap sizedi: 0.
WeakHashMapha solo riferimenti deboli alle chiavi, non riferimenti forti come altre Mapclassi. Ci sono situazioni che devi fare attenzione quando il valore o la chiave è fortemente referenziato anche se hai usato WeakHashMap. Questo può essere evitato avvolgendo l'oggetto in un 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");
}
}
Riferimenti morbidi.
Soft Referenceè leggermente più forte di quel riferimento debole. Il riferimento software consente la raccolta dei rifiuti, ma chiede al garbage collector di cancellarlo solo se non ci sono altre opzioni.
Il garbage collector non raccoglie in modo aggressivo oggetti delicatamente raggiungibili come fa con quelli debolmente raggiungibili - invece raccoglie oggetti delicatamente raggiungibili solo se "ha bisogno" della memoria. I riferimenti morbidi sono un modo di dire al garbage collector, "Finché la memoria non è troppo stretta, mi piacerebbe tenere questo oggetto in giro. Ma se la memoria diventa davvero stretta, vai avanti e raccoglilo e mi occuperò con quello." Il garbage collector deve cancellare tutti i riferimenti software prima di poterlo lanciare OutOfMemoryError.