Schwache Referenz
http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/ref/WeakReference.html
Prinzip: weak reference bezieht sich auf die Speicherbereinigung. Normalerweise kann ein Objekt mit einem oder mehreren Objekten referencenicht zur Speicherbereinigung verwendet werden.
Das obige Prinzip ist nicht anwendbar, wenn es ist weak reference. Wenn ein Objekt nur eine schwache Referenz zu anderen Objekten hat, ist es für die Speicherbereinigung bereit.
Schauen wir uns das folgende Beispiel an: Wir haben ein Mapwith Objects, bei dem Key auf ein Objekt verweist.
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());
}
}
Nun, während der Ausführung des Programms haben wir gemacht emp = null. Das MapHalten des Schlüssels macht hier so wie es ist keinen Sinn null. In der obigen Situation wird das Objekt nicht durch Müll gesammelt.
WeakHashMap
WeakHashMapIn key-to-value mappingsdiesem Fall werden die Einträge ( ) entfernt, wenn sie nicht mehr von der abgerufen werden können Map.
Lassen Sie mich das obige Beispiel mit WeakHashMap zeigen
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());
}
}
Ausgang: Nahm 20 calls to System.gc()zu Folge in aMap sizeder: 0.
WeakHashMaphat nur schwache Verweise auf die Schlüssel, keine starken Verweise wie andere MapKlassen. Es gibt Situationen, auf die Sie achten müssen, wenn der Wert oder Schlüssel stark referenziert wird, obwohl Sie ihn verwendet haben WeakHashMap. Dies kann vermieden werden, indem das Objekt in eine WeakReference eingeschlossen wird .
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");
}
}
Weiche Referenzen.
Soft Referenceist etwas stärker als die schwache Referenz. Die weiche Referenz ermöglicht die Speicherbereinigung, bittet den Speicherbereiniger jedoch, sie nur zu löschen, wenn keine andere Option vorhanden ist.
Der Garbage Collector sammelt nicht wie bei schwach erreichbaren Objekten aggressiv erreichbare Objekte aggressiv, sondern nur dann, wenn er den Speicher wirklich "benötigt". Weiche Referenzen sind eine Möglichkeit, dem Garbage Collector zu sagen: "Solange der Speicher nicht zu eng ist, möchte ich dieses Objekt behalten. Aber wenn der Speicher sehr knapp wird, sammeln Sie es und ich werde mich darum kümmern." damit." Der Garbage Collector muss alle weichen Referenzen löschen, bevor er werfen kann OutOfMemoryError.