Jetons un coup d'œil à ce que sont les références « faibles » en Java ?

Tutoriel Java de baseLa colonne présente les citations "faibles" de Java

Recommandé (gratuit) : Tutoriel Java de base

Lorsqu'un objet obj est créé en Java, il est placé sur le tas. Lorsque le GC s'exécute et constate qu'il n'y a aucune référence pointant vers obj, l'espace mémoire tas de l'objet obj sera récupéré.

Autrement dit, pour qu'un objet soit recyclé, deux conditions doivent être remplies :

(1) Il n'y a aucune référence le pointant

(2) GC est exécuté.

Dans le développement réel, nous pouvons garantir que l'objet sera recyclé lors de la prochaine exécution du GC en définissant tous les points de référence sur un objet vide, semblable à ce qui suit :

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

Cependant, cette opération c'est très fastidieux et va à l'encontre du principe du recyclage automatique des GC. Pour les cas simples, le paramétrage manuel n'est pas requis par les programmeurs, car en Java, pour les objets simples, lorsque la méthode qui l'appelle est exécutée, la référence pointant vers celui-ci sera extraite de la pile, elle pourra donc être recyclée lors du prochain Exécution du GC.

Cependant, il existe des exceptions spéciales. Lors de l'utilisation du cache, puisque les objets dans le cache sont exactement ce dont le programme a besoin pour s'exécuter, tant que le programme est en cours d'exécution, les références dans le cache ne seront pas GC ( ou en d'autres termes, dans le cache (les références ont le même cycle de vie que le programme principal). Puis comme il y a de plus en plus de références dans le cache, de plus en plus d'objets ne peuvent pas être recyclés par le GC et ne peuvent pas être recyclés automatiquement. Lorsque ces objets doivent être recyclés, la tâche de recycler ces objets ne peut être laissée qu'au programmeur. Or, cela va à l’encontre de l’essence du GC (recyclage automatique des objets recyclables).

Ainsi, une référence faible a été introduite en Java.

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

Quand un objet est uniquement pointé par une référence faible sans aucune autre référence forte, si le GC s'exécute, alors l'objet sera recyclé.

Ce qui suit est un exemple tiré d'Internet. Définissez d'abord une classe d'entité :

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;
    }
}

Généralement, lorsque vous utilisez WeakReference, vous définirez une classe qui hérite de WeakReference, puis définirez d'autres attributs dans cette classe. Aucun autre attribut n'est défini ici :

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

Appelez la fonction principale. Bien sûr, afin de voir plus clairement l'effet de GC, définissez le paramètre de machine virtuelle "-XX:+PrintGCDetails":

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;
        }
    }
}

Le dernier est le résultat d'exécution

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

Vous pouvez voir qu'après la boucle 68454, l'objet Car associé à la WeakReferenceCar est recyclé. Notez que l'objet car associé à la référence faible est recyclé. , pas la référence faible elle-même wrc.

L'une des caractéristiques de WeakReference est qu'il est incertain du moment où il sera recyclé, car cela est déterminé par l'incertitude du fonctionnement du GC. Par conséquent, les objets référencés par des références faibles sont généralement précieux et mis en cache. un objet facile à reconstruire et qui consomme beaucoup de mémoire.

Une fois l'objet pointé par la référence faible recyclé, la référence faible elle-même est en fait inutile. Java fournit une ReferenceQueue pour enregistrer ces références. qui pointe vers un objet qui a été recyclé. L'utilisation est de passer un objet ReferenceQueue en tant que paramètre dans le constructeur lors de la définition de WeakReference.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!