Comprendre et utiliser les références faibles Java

En Java, lorsqu'un objet est créé, il est placé dans le tas mémoire Lorsque le GC s'exécute, s'il s'avère qu'il n'y a aucune référence pointant vers l'objet, l'objet. sera recyclé pour libérer de l'espace mémoire.

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

1) Il n'y a aucune référence le pointant (apprentissage recommandé : cours java )

2) GC est exécuté.

Pour les situations simples en Java, les programmeurs n'ont pas besoin de le mettre manuellement vide, 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 recyclée par GC ,

En fait, lorsque nous écrivons du code, nous définissons souvent toutes les références pointant vers un certain objet sur null, comme :

Person p = new Person("张三",18,"男");//强引用
...
p=null;//不再使用的时候置null

Évidemment, pour les programmeurs, définir manuellement des objets nuls est fastidieux et viole le mécanisme de recyclage automatique.

Pour des situations simples, comme les objets locaux générés dans les méthodes, Java n'exige pas que les programmeurs les vident manuellement Lorsque la méthode qui l'appelle est exécutée, la référence pointant vers elle sera recyclée par GC.

Dans une situation plus compliquée, comme l'utilisation du cache, parce que les objets dans le cache sont exactement ce dont le programme a besoin pour s'exécuter, alors tant que le programme est en cours d'exécution, les références dans le cache ne seront pas GCed , ainsi que les références dans le cache Il y a de plus en plus d'objets qui ne peuvent pas être recyclés par GC et qui ne peuvent pas être automatiquement recyclés. À l'heure actuelle, les développeurs doivent gérer le recyclage, ce qui viole évidemment le mécanisme de recyclage automatique de Java.

À cet égard, des références faibles (WeakReference) ont été introduites en Java.

Lorsqu'un objet est pointé uniquement par une référence faible sans aucune autre référence forte, si le GC s'exécute, alors l'objet sera recyclé. Si une référence forte existe et y est associée, l'objet ne sera pas récupéré lors du garbage collection.

La syntaxe de WeakReference :

WeakReference<T> weakReference = new WeakReference<T>(referent);

Lorsque l'on souhaite obtenir l'objet référencé par la référence faible, il faut d'abord déterminer s'il a été recyclé :

weakReference.get();

If Si cette méthode est vide, cela signifie que l'objet pointé par lowReference a été recyclé.

Ce qui suit est une châtaigne de WeakReference :

Classe de personne :

package com.yx.test.model;
 
/**
 * Person
 *
 * @author yx
 * @date 2019/11/26 16:28
 */
public class Person {
    private String name;
    private int age;
    private String sex;
 
    public Person() {
    }
 
    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getSex() {
        return sex;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
}

Classe de test TestWeakReference :

package com.yx.test.reference;
 
import com.yx.test.model.Person;
 
import java.lang.ref.WeakReference;
 
/**
 * TestWeakReference
 *
 * @author yx
 * @date 2019/11/26 16:30
 */
public class TestWeakReference {
    public static void main(String[] args) {
        Person p = new Person("张三",18,"男");
        WeakReference<Person> weakPerson = new WeakReference<Person>(p);
        int i=0;
        while(true){
            if(weakPerson.get()!=null){
                i++;
                System.out.println("Object is alive for "+i+" loops - "+weakPerson);
            }else{
                System.out.println("Object has been collected.");
                break;
            }
        }
    }
}

Résultats de fonctionnement :

p is alive for 1 loops - java.lang.ref.WeakReference@330bedb4
...
p is alive for 62331 loops - java.lang.ref.WeakReference@330bedb4
p is alive for 62332 loops - java.lang.ref.WeakReference@330bedb4
p has been collected.

Comme vous pouvez le voir, une fois la boucle while exécutée des dizaines de milliers de fois, p est recyclé.

J'ai testé et exécuté le programme plusieurs fois et j'ai constaté que le nombre d'exécutions de boucle pendant le recyclage p est incertain : car cela est déterminé par l'incertitude du fonctionnement du GC.

Résumé :

1. En Java, lorsqu'un objet n'est référencé que par une référence faible, si le GC s'exécute, alors l'objet sera recyclé.

2. Une caractéristique d'une référence faible est qu'elle ne sait pas quand elle sera recyclée

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!