Java-Referenzen

Einer der Vorteile der Java-Sprache besteht darin, dass sie den Speicher automatisch verwaltet. Der Programmierer muss sich nicht um die Last der Speicherverwaltung kümmern und muss sich keine Sorgen machen, den Speicher des Objekts freizugeben, wenn das Objekt nicht mehr benötigt wird. Der Java Garbage Collector Thread erledigt dies für den Programmierer; Es entfernt das unerwünschte Objekt und gibt den Speicher frei, indem es unter der Kontrolle der JVM steht. Mithilfe der java.lang.ref-Klassen kann der Programmierer bei Bedarf auch steuern, wann Objekte durch Garbage Collection erfasst werden. Es gibt vier Arten von Referenzen in Java, basierend auf der Art und Weise, wie sie durch Garbage Collection gesammelt werden, oder basierend auf dem Verhalten des Garbage Collectors in Bezug auf die Referenzen.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Arten von Java-Referenzen mit Beispielen

Es gibt vier Arten von Java-Referenzen, basierend auf dem Verhalten des Garbage Collectors in Bezug auf die Referenzen.

• Starke Referenzen: Dies ist die Standardreferenz in Java. Starke Referenzen können erstellt werden, wenn ein Objekt regelmäßig definiert wird.
• Schwache Referenzen: Diese Referenz muss explizit angegeben werden. Die schwachen Referenzen können mithilfe der Klasse java.lang.ref.WeakReference erstellt werden.
• Soft-Referenzen: Soft-Referenzen können mithilfe der Klasse lang.ref.SoftReference erstellt werden.
• Phantom-Referenzen: Die Phantom-Referenzen können mithilfe der Klasse lang.ref.PhantomReference erstellt werden.

1. Starke Referenzen

Eine starke Referenz verwenden wir normalerweise, während wir den Java-Code schreiben oder ein Objekt erstellen. Ein Objekt, das über eine starke Referenz verfügt und im Speicher aktiv ist, kommt nicht für die Garbage Collection in Frage. Ein Objekt, dessen starke Referenz auf Null zeigt, kann für die Garbage Collection ausgewählt werden. Zum Beispiel das folgende Codefragment, bei dem die Variable ob das Objekt vom Typ ClassA ist.

ClassA ob = new ClassA();

Ein „ob“-Objekt hat einen starken Verweis auf die Klasse ClassA; Dieses Objekt kann nicht durch Garbage Collection gesammelt werden, da ein Ob ein aktives Objekt ist.

Wenn die Referenz „ob“ wie unten auf Null verweist –

ob = null;

Jetzt verweist das Objekt nicht auf die Klasse ClassA; Ein Objekt ist jetzt für die Garbage Collection geeignet.

Beispiel

Code:

package p1;
class ClassA
{
// something
}
public class Demo {
public static void main( String[] arg )
{
ClassA ob = new ClassA(); // default reference or Strong Reference
System.out.println(ob);
ob = null; // Now object <u>ob</u> pointing to null and is available for garbage collection
System.out.println(ob);
}
}

Ausgabe:

2. Schwache Referenzen

Die schwache Referenz ist für die Garbage Collection geeignet. Sobald JVM ein Objekt mit schwacher Referenz erkennt, wird dieses Objekt markiert und Müll wird gesammelt, wenn der Garbage-Collector-Thread von JVM ausgeführt wird. Diese Arten von Referenzen werden in WeakHashMap für den Objekteintrag verwendet. Die schwachen Referenzen können von der Klasse lang.ref.WeakReference erstellt werden. Die schwache Referenz, die in einer Anwendung verwendet werden kann, besteht darin, DBConnection einzurichten und nach dem Schließen der Datenbank die Verbindung durch Garbage Collector freizugeben. Zum Beispiel das folgende Codefragment, bei dem die Variable ob das Objekt vom Typ ClassA ist.

ClassA ob = new ClassA();

Ein „ob“-Objekt ist eine starke Referenz, um es sammelbar zu machen. Wir müssen seine Referenz wie folgt in eine schwache Referenz umwandeln –

WeakReference<ClassA> weakob = new WeakReference<ClassA>(ob);

Das Objekt verweist jetzt nur noch schwach auf die Klasse ClassA, ein Objekt steht nun für die Garbage Collection zur Verfügung und es wird Garbage Collection durchgeführt, wenn die JVM den Garbage Collection-Thread ausführt.

Beispiel

Code:

package p1;
import java.lang.ref.WeakReference;
class ClassA
{
// something
}
public class Demo {
public static void main( String[] arg )
{
ClassA ob = new ClassA();  // default reference or Strong Reference
System.out.println(ob);
// now create Weak Reference object to which <u>ob</u> object is pointing
WeakReference <ClassA> weakob = new WeakReference <ClassA>(ob);
// Now <u>ob</u> object is eligible for garbage collection, but it will be remove from memory when JVM needs memory
ob = null;
System.out.println(ob);
// weakly referenced <u>ob</u> object can get back
ob = weakob.get();
System.out.println(ob);
}
}

Ausgabe:

3. Weiche Referenzen

Das Objekt der Soft-Referenz ist erst dann für die Speicherbereinigung geeignet, wenn der JVM der Speicher ausgeht oder die JVM dringend Speicher benötigt. Die schwachen Referenzen können durch die Klasse lang.ref.SoftReference erstellt werden. Beispielsweise kann die weiche Referenz ähnlich wie die schwache Referenz erstellt werden.

SoftReference <ClassA> softob = new SoftReference <ClassA>(ob);

Beispiel

Code:

package p1;
import java.lang.ref.SoftReference;
class ClassA
{
// something
}
public class Demo {
public static void main( String[] arg )
{
ClassA ob = new ClassA();// default reference or Strong Reference
System.out.println(ob);
// now create soft Reference object which ob object is pointing
SoftReference <ClassA> softob = new SoftReference <ClassA>(ob);
// Now ob object is eligible for garbage collection, but it will be garbage collected when JVM badly needs memory
ob = null;
System.out.println(ob);
// the soft referenced, ob object can get back
ob = softob.get();
System.out.println(ob);
}
}

Ausgabe:

4. Phantom-Referenzen

Ein Objekt mit Phantomreferenz steht für die Garbage Collection zur Verfügung, aber vor der Garbage Collection wird ein Objekt von der JVM in eine Referenzwarteschlange gestellt, die als „Referenzwarteschlange“ bezeichnet wird. nach dem Funktionsaufruf finalize() für das Objekt. Die schwachen Referenzen können von der Klasse lang.ref erstellt werden. PhantomReference.

Beispiel

Code:

package p1;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.PhantomReference;
class ClassA
{
// something
}
public class Demo {
public static void main( String[] arg )
{
ClassA ob = new ClassA();  // default reference or Strong Reference
System.out.println(ob);
// now Create Reference queue object
ReferenceQueue <ClassA> refq = new ReferenceQueue <ClassA>();
// Create Phantom Reference object to which <u>ob</u> object is pointing
PhantomReference <ClassA> phantomob = new PhantomReference <ClassA>(ob,refq);
// Now <u>ob</u> object is eligible for garbage collection, but it will be kept in '<u>refq</u>' before removing
ob = null;
System.out.println(ob);
// to get back object which has been Phantom referenced returns null
ob = phantomob.get();
System.out.println(ob);
}
}

Ausgabe:

Das obige ist der detaillierte Inhalt vonJava-Referenzen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!