Comment la classe interne anonyme Java résout-elle le problème de fuite de mémoire ?

Les classes internes anonymes peuvent provoquer des fuites de mémoire. Le problème est qu'elles contiennent une référence à la classe externe, empêchant ainsi la classe externe d'être récupérée. Les solutions incluent : 1. Utiliser des références faibles. Lorsque la classe externe n'est plus détenue par une référence forte, le garbage collector recyclera immédiatement l'objet de référence faible ; 2. Utiliser des références logicielles lorsqu'il sera utilisé. a besoin de mémoire pendant le garbage collection. Ce n'est qu'alors que l'objet de référence logiciel est recyclé. En pratique, comme dans les applications Android, le problème de fuite de mémoire provoqué par des classes internes anonymes peut être résolu en utilisant des références faibles, de sorte que la classe interne anonyme puisse être recyclée lorsque l'écouteur n'est pas nécessaire.

Classes internes anonymes Java : Comment réparer une fuite de mémoire

Introduction

Les classes internes anonymes sont des classes internes sans nom qui sont écrites directement dans la classe ou la méthode qui les crée. Bien que les classes internes anonymes puissent simplifier le code, elles peuvent entraîner des fuites de mémoire si elles ne sont pas gérées correctement.

Création de fuites mémoire

Une fuite mémoire se produit lorsqu'une classe interne anonyme détient une référence à sa classe externe. La classe externe empêche le garbage collection et la classe interne restera en mémoire même si elle n'est plus nécessaire.

Solution de contournement

Les fuites de mémoire dans les classes internes anonymes peuvent être résolues en utilisant des références faibles ou des références douces. Ces références permettent au garbage collector de récupérer l'objet si nécessaire, tout en autorisant l'accès à l'objet s'il n'a pas déjà été récupéré.

Utilisez des références faibles

Les références faibles sont le type de référence le plus faible. Lorsqu'un objet n'est plus détenu par aucune référence forte, le garbage collector récupère immédiatement l'objet contenant une référence faible.

public class Example {

    private static class InnerClass {
        // ...
    }

    public static void main(String[] args) {
        // 创建外部类对象
        Example example = new Example();

        // 创建持有外部类引用的匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // ...
            }
        };

        // 将匿名内部类弱引用
        WeakReference<Runnable> weakRunnable = new WeakReference<>(runnable);

        // ...

        // 显式取消强引用
        runnable = null;

        // 垃圾回收器将回收匿名内部类，因为只有弱引用持有其引用
    }
}

Utilisez des références douces

Les références douces sont plus fortes que les références faibles. Le garbage collector récupère uniquement les objets contenant des références logicielles lorsqu'il a besoin de mémoire lors de l'exécution du garbage collection.

public class Example {

    private static class InnerClass {
        // ...
    }

    public static void main(String[] args) {
        // 创建外部类对象
        Example example = new Example();

        // 创建持有外部类引用的匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // ...
            }
        };

        // 将匿名内部类软引用
        SoftReference<Runnable> softRunnable = new SoftReference<>(runnable);

        // ...

        // 显式取消强引用
        runnable = null;

        // 垃圾回收器可能会在需要内存时回收匿名内部类，但只有当内存不足时才会回收
    }
}

Cas pratique

Ce qui suit est un cas pratique de résolution de fuites de mémoire causées par des classes internes anonymes dans les applications Android :

public class MyActivity extends Activity {

    private Button button;
    private View.OnClickListener listener;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);

        button = findViewById(R.id.button);

        // 使用弱引用解决内存泄漏
        listener = new WeakReference<>(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // ...
            }
        }).get();

        button.setOnClickListener(listener);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 在 Activity 销毁时取消强引用
        listener = null;
    }
}

En utilisant des références faibles, vous pouvez vous assurer que les classes internes anonymes sont récupérées lorsque l'auditeur est pas nécessaire, évitant ainsi les fuites de mémoire.

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!