Einführung in die Verwendung von Referenzen in Java

In diesem Artikel werden hauptsächlich relevante Informationen zur detaillierten Erklärung der Referenzverwendung in Java vorgestellt. Freunde, die sie benötigen, können sich auf

Ausführliche Erklärung der Java-Referenz

in JDK beziehen 1.2 und seine Später wurden die vier Konzepte starker Referenz , weiche Referenz, schwache Referenz und virtuelle Referenz eingeführt. Es gibt viele Erklärungen zu diesen vier Konzepten im Internet, aber die meisten davon sind konzeptionell und allgemein. Heute habe ich sie anhand des Codes analysiert. Schauen wir uns zunächst die Definition und die allgemeine Erklärung an (Referenztypen sind im Paket Java enthalten). 🎜>lang.ref).

　1. Starke Referenz (StrongReference)

　 Starke Referenz wird von GC nicht recycelt und es gibt keinen tatsächlichen entsprechenden Typ in java.lang.ref. Zum Beispiel:

　Object obj = new Object();

Die Obj-Referenz hier ist eine starke Referenz und wird von GC nicht recycelt.

2. Soft-Referenz

Soft-Referenz wird von GC nur recycelt, wenn die JVM nicht genügend Speicher meldet, andernfalls wird sie nicht recycelt. Genau aus diesem Grund Feature-Soft-Referenzen werden häufig beim Caching und Pooling verwendet. Verwendung von Soft-Referenzen:

Object obj = new Object();
SoftReference<Object> softRef = new SoftReference(obj);
// 使用 softRef.get() 获取软引用所引用的对象
Object objg = softRef.get();

3. Schwache Referenz (WeakReference)

Wenn GC ein schwaches Referenzobjekt entdeckt, Das von WeakReference referenzierte Objekt wird freigegeben. Die Verwendung schwacher Referenzen ähnelt der Verwendung weicher Referenzen, die Recyclingstrategie ist jedoch unterschiedlich.

　

　4. Phantomreferenz (PhantomReference)

　 Sobald der GC das virtuelle Referenzobjekt erkennt, fügt er das PhantomReference-Objekt in die ReferenceQueue

Warteschlange ein Zu diesem Zeitpunkt wurde das Objekt, auf das PhantomReference zeigt, nicht vom GC recycelt, es wird jedoch erst recycelt, wenn die ReferenceQueue tatsächlich von Ihnen verarbeitet wird. Verwendung virtueller Referenzen:

Object obj = new Object();
ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();
PhantomReference<Object> phanRef = new PhantomReference<Object>(obj, refQueue);
// 调用phanRef.get()不管在什么情况下会一直返回null
Object objg = phanRef.get();
// 如果obj被置为null，当GC发现了虚引用，GC会将phanRef插入进我们之前创建时传入的refQueue队列
// 注意，此时phanRef所引用的obj对象，并没有被GC回收，在我们显式地调用refQueue.poll返回phanRef之后
// 当GC第二次发现虚引用，而此时JVM将phanRef插入到refQueue会插入失败，此时GC才会对obj进行回收
Reference<? extends Object> phanRefP = refQueue.poll();

Nachdem wir die einfache Definition gelesen hatten, kombinierten wir den Code, um ihn zu testen. Selbstverständlich werden starke Referenzen auch in weichen Referenzen beschrieben. Es ist klar, dass der Schlüssel „schwache Referenz“ und „virtuelle Referenz“ ist.

Schwache Referenz:

public static void main(String[] args) throws InterruptedException {
  Object obj = new Object();
  ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();
  WeakReference<Object> weakRef = new WeakReference<Object>(obj, refQueue);
  System.out.println(weakRef.get());
  System.out.println(refQueue.poll());
  obj = null;
  System.gc();
  System.out.println(weakRef.get());
  System.out.println(refQueue.poll());
}

Da System.gc() der JVM mitteilt, dass dies ein guter Zeitpunkt ist GC ausführen, aber die spezifische Ausführung oder nicht wird von der JVM bestimmt. Wenn die JVM also beschließt, GC auszuführen, ist das Ergebnis (tatsächlich führt dieser Code im Allgemeinen GC aus):

　　java.lang.Object@de6ced
　　null
　　null
　　java.lang.ref.WeakReference@1fb8ee3

Aus den Ausführungsergebnissen wissen wir, dass wir durch den Aufruf von schwachRef.get() das obj-Objekt erhalten. Da GC nicht ausgeführt wird, gibt refQueue.poll() null zurück ist keine Referenz, die auf den Heap verweist. Hier hat die JVM einen GC durchgeführt. Wir haben festgestellt, dass null durch schwachRef.get() zurückgegeben wurde, und daher hat die JVM das schwachRef in das obj-Objekt, nachdem es in der refQueue-Warteschlange recycelt wurde.

Dummy-Referenz:

public static void main(String[] args) throws InterruptedException {
  Object obj = new Object();
  ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();
  PhantomReference<Object> phanRef = new PhantomReference<Object>(obj, refQueue);
  System.out.println(phanRef.get());
  System.out.println(refQueue.poll());
  obj = null;
  System.gc();
  System.out.println(phanRef.get());
  System.out.println(refQueue.poll());
}

In ähnlicher Weise lautet das Ergebnis, wenn die JVM GC ausführt:

　　null
　　null
　　null
　　java.lang.ref.PhantomReference@1fb8ee3

Aus den Ausführungsergebnissen wissen wir, dass das, was wir zuvor gesagt haben, unabhängig von den Umständen null zurückgibt dass die virtuelle Nach der Referenz recycelt die JVM nicht obj, sondern fügt das PhantomReference-Objekt in die entsprechende virtuelle Referenzwarteschlange refQueue ein. Wenn refQueue.poll() aufgerufen wird, um das PhantomReference-Objekt zurückzugeben, stellt die Poll-Methode zunächst die Haltewarteschlange der PhantomReference in die Warteschlange (ReferenceQueue< ?

super T>) wird auf NULL gesetzt, das NULL-Objekt erbt von ReferenceQueue und die Methode enqueue(Reference paramReference) wird mit return überschrieben false, und zu diesem Zeitpunkt ist obj wieder vorhanden. Wenn es vom GC erkannt wird, fügt die JVM die PhantomReference in die NULL-Warteschlange ein und gibt false zurück, wenn das Einfügen fehlschlägt. Zu diesem Zeitpunkt recycelt der GC obj. Tatsächlich können wir anhand dieses Codes nicht erkennen, ob obj recycelt wird, aber es gibt einen Satz im Javadoc Kommentar von PhantomReference, der lautet:

Sobald der Müll vorhanden ist, entscheidet der Sammler dass ein Objektobjekt phantom-rjederfähig ist, es in die entsprechende Warteschlange eingereiht wird, aber sein Referent nicht freied ist, also in der Referenzwarteschlange der Phantomreferenz muss explizit von einem Anwendungscode verarbeitet werden.

Übersetzung (dieser Satz ist sehr einfach, ich glaube, viele Leute sollten ihn verstehen):

Sobald der GC entscheidet, dass ein „obj“ vorliegt Wenn es virtuell erreichbar ist, wird es (bezogen auf PhantomReference) in die entsprechende Warteschlange eingereiht, seine Referenz wurde jedoch nicht gelöscht. Das heißt, die Referenzwarteschlange virtueller Referenzen muss explizit von einem Anwendungscode behandelt werden.

Die Verwendung schwacher Referenzen und virtueller Referenzen

　　软引用很明显可以用来制作caching和pooling，而弱引用与虚引用呢？其实用处也很大，首先我们来看看弱引用，举个例子：

class Registry {
  private Set registeredObjects = new HashSet();
 
  public void register(Object object) {
    registeredObjects.add( object );
  }
}

所有我添加进 registeredObjects 中的object永远不会被GC回收，因为这里有个强引用保存在registeredObjects里，另一方面如果我把代码改为如下：

class Registry {
   private Set registeredObjects = new HashSet();
 
   public void register(Object object) {
     registeredObjects.add( new WeakReference(object) );
   }
 }

  现在如果GC想要回收registeredObjects中的object，便能够实现了，同样在使用HashMap如果想实现如上的效果，一种更好的实现是使用WeakHashMap。

而虚引用呢？我们先来看看javadoc的部分说明：

Phantom references are useful for implementing cleanup operations that are necessary before an object gets garbage-collected. They are sometimes more flexible than the finalize() method.

翻译一下：

虚引用在实现一个对象被回收之前必须做清理操作是很有用的。有时候，他们比finalize()方法更灵活。

很明显的，虚引用可以用来做对象被回收之前的清理工作。

Das obige ist der detaillierte Inhalt vonEinführung in die Verwendung von Referenzen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!