Werfen wir einen Blick darauf, was „schwache“ Referenzen in Java sind.

Java-Basis-TutorialSpalte stellt Java-„schwache“ Referenz vor

Empfohlen (kostenlos): Java-Basis-Tutorial

Wenn ein Objekt obj in Java erstellt wird, wird es in der platziert Haufen. Wenn der GC ausgeführt wird und feststellt, dass keine Referenz auf obj verweist, wird der Heap-Speicherplatz des obj-Objekts zurückgefordert.

Mit anderen Worten, damit ein Objekt recycelt werden kann, müssen zwei Bedingungen erfüllt sein:

(1) Es gibt keinen Verweis darauf.

(2) GC wird ausgeführt.

In der tatsächlichen Entwicklung können wir sicherstellen, dass das Objekt beim nächsten Ausführen des GC recycelt wird, indem wir alle Referenzpunkte auf ein Objekt leeren, ähnlich wie im Folgenden:

Object c = new Car();    
c=null;

Dies ist jedoch sehr umständlich und verstößt gegen Es geht um den GC Automatisches Recyclingprinzip. In einfachen Fällen ist eine manuelle Einstellung durch Programmierer nicht erforderlich, da in Java bei einfachen Objekten beim Ausführen der Methode, die sie aufruft, die darauf verweisende Referenz vom Stapel entfernt wird, sodass sie beim nächsten Mal wiederverwendet werden kann GC-Ausführung.

Bei der Verwendung des Caches gibt es jedoch besondere Ausnahmen, da die Objekte im Cache genau das sind, was das Programm zum Ausführen benötigt. Solange das Programm ausgeführt wird, sind die Referenzen im Cache nicht Eigentum von GC (oder, Mit anderen Worten, die Referenzen im Cache) Derselbe Lebenszyklus wie das Hauptprogramm. Da sich dann immer mehr Referenzen im Cache befinden, können immer mehr Objekte vom GC nicht recycelt werden und können nicht automatisch recycelt werden. Wenn diese Objekte recycelt werden müssen, kann die Aufgabe des Recyclings dieser Objekte nur dem Programmierer überlassen werden. Dies widerspricht jedoch dem Wesen von GC (automatisches Recycling von wiederverwertbaren Objekten).

Also wurde in Java eine schwache Referenz eingeführt.

Object c = new Car(); //只要c还指向car object, car object就不会被回收 -->（强引用）

Wenn auf ein Objekt nur durch eine schwache Referenz ohne eine andere starke Referenz verwiesen wird und der GC ausgeführt wird, wird das Objekt recycelt.

Das Folgende ist ein Beispiel aus dem Internet:

public class Car {
    private double     price;
    private String    color;

    public Car(double price, String color)
    {
        this.price = price;
        this.color = color;
    }

    public double getPrice()
    {
        return price;
    }

    public String getColor()
    {
        return color;
    }

    public String toString()
    {
        return "This car is a " + this.color + " car, costs $" + price;
    }
}

Im Allgemeinen wird bei der Verwendung von WeakReference eine Klasse definiert, die von WeakReference erbt, und in dieser Klasse werden keine anderen Attribute definiert :

public class WeakReferenceCar extends WeakReference<Car>
{
    public WeakReferenceCar(Car car)
    {
        super(car);
    }
}

Rufen Sie die Hauptfunktion auf. Um den Effekt von GC klarer zu sehen, legen Sie natürlich die Parameter der virtuellen Maschine fest:

public static void main(String[] args)
{
    Car car = new Car(2000.0, "red");
    WeakReferenceCar wrc = new WeakReferenceCar(car);
    wrc.setStr("111");
    int i = 0;
    while (true)
    {
        if (wrc.get() != null)
        {
            i++;
            System.out.println("WeakReferenceCar's Car is alive for " + i + ", loop - " + wrc);
        }
        else
        {
            System.out.println("WeakReferenceCar's Car has bean collected");
            break;
        }
    }
}

Das letzte ist das laufende Ergebnis

WeakReferenceCar's Car is alive for 68450, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68451, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68452, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68453, loop - interview.WeakReferenceCar@776ec8df
[GC (Allocation Failure) [PSYoungGen: 34304K->1000K(38400K)] 34320K->1016K(125952K), 0.0015129 secs] [Times: user=0.02 sys=0.02, real=0.00 secs] 
WeakReferenceCar's Car is alive for 68454, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car has bean collected
Heap
PSYoungGen      total 38400K, used 1986K [0x00000000d5e00000, 0x00000000da900000, 0x0000000100000000)
eden space 33280K, 2% used [0x00000000d5e00000,0x00000000d5ef6b70,0x00000000d7e80000)
from space 5120K, 19% used [0x00000000d7e80000,0x00000000d7f7a020,0x00000000d8380000)
to   space 5120K, 0% used [0x00000000da400000,0x00000000da400000,0x00000000da900000)
ParOldGen       total 87552K, used 16K [0x0000000081a00000, 0x0000000086f80000, 0x00000000d5e00000)
object space 87552K, 0% used [0x0000000081a00000,0x0000000081a04000,0x0000000086f80000)
Metaspace       used 3547K, capacity 4564K, committed 4864K, reserved 1056768K
class space    used 381K, capacity 388K, committed 512K, reserved 1048576K

Sie können sehen, dass nach der 68454-Schleife das mit „WeakReferenceCar“ verknüpfte Objekt „Car“ recycelt wurde. Beachten Sie, dass das mit der schwachen Referenz verknüpfte Objekt „Car“ recycelt wurde, nicht die schwache Referenz selbst.

Eines der Merkmale von WeakReference ist, dass es ungewiss ist, wann es recycelt wird, da dies durch die Unsicherheit des GC-Betriebs bestimmt wird. Daher sind Objekte, auf die durch schwache Referenzen verwiesen wird, im Allgemeinen wertvoll und können leicht zwischengespeichert werden Diese werden neu erstellt und verbrauchen viel Speicher.

Nachdem das Objekt, auf das die schwache Referenz verweist, recycelt wird, stellt die schwache Referenz selbst tatsächlich eine Referenzwarteschlange bereit, um die Referenzen zu speichern, auf die die Objekte verweisen. Die Verwendung besteht darin, beim Definieren von WeakReference.

ein ReferenceQueue-Objekt als Parameter an den Konstruktor zu übergeben

Das obige ist der detaillierte Inhalt vonWerfen wir einen Blick darauf, was „schwache“ Referenzen in Java sind.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!