Quels sont les scénarios courants de fuite de mémoire en Java ?

Les scénarios courants de fuite de mémoire en Java incluent : la conservation de références à des objets externes, des références statiques, des écouteurs non valides, des variables locales de thread et des références circulaires. Les scénarios courants de fuite de mémoire sur les serveurs d'applications incluent des threads contenant des références à des objets de servlet, des supports statiques contenant des références à des connexions persistantes et des écouteurs non supprimés des composants.

Scénarios courants de fuite de mémoire en Java

Les fuites de mémoire sont un défaut grave dans le développement logiciel qui peut entraîner des plantages d'applications ou une dégradation des performances au fil du temps. Voici les scénarios de fuite de mémoire les plus courants en Java :

1. Conserver une référence à un objet externe

Lorsqu'un objet contient une référence à un objet externe, la JVM ne peut pas récupérer l'objet externe alors qu'il ne l'est pas. utilisé. . Par exemple :

class Outer {
    private Inner inner;

    public Outer() {
        inner = new Inner();  // 持有对 Inner 的引用
    }
}

class Inner {
    // ...
}

2. Références statiques

Les variables statiques sont stockées dans la mémoire permanente de la JVM et ne sont jamais récupérées. Si une variable statique contient une référence à un objet, l'objet ne peut pas être récupéré. Par exemple :

public class Example {
    private static List<Object> objects = new ArrayList<>();

    public static void main(String[] args) {
        objects.add(new Object());
    }
}

3. Écouteur invalide

Une fuite de mémoire se produit lorsqu'un écouteur n'est plus utilisé mais est toujours attaché à une source d'événement. Par exemple :

import javax.swing.*;

public class ListenerLeak {
    private JButton button;

    public ListenerLeak() {
        button = new JButton();
        button.addActionListener(e -> {
            // ...
        });
    }

    // 忘记从按钮中移除监听器
}

4. Variables locales du thread

Les variables locales du thread sont stockées dans le stockage local du thread (TLS) de chaque thread, et elles ne sont pas récupérées tant que le thread est actif. Si vous utilisez des variables locales de thread dans un thread terminé, vous risquez de provoquer une fuite de mémoire. Par exemple :

public class ThreadLocalLeak {
    private static ThreadLocal<Object> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            threadLocal.set(new Object());  // 在线程中设置值
        });
        thread.start();
        thread.interrupt();  // 中断线程

        // 线程局部存储未得到清理
    }
}

5. Référence circulaire

Une référence circulaire se produit lorsque deux objets ou plus se réfèrent l'un à l'autre. Cela empêche la JVM de reconnaître qu'ils ne sont plus utilisés, ce qui entraîne une fuite de mémoire. Par exemple :

public class CycleReference {
    private CycleReference other;

    public CycleReference() {
        other = new CycleReference();
        other.other = this;  // 循环引用
    }
}

Cas pratique

Fuites de mémoire dans les serveurs d'applications

Voici des scénarios typiques de fuite de mémoire dans les serveurs d'applications :

1. Les threads enregistrent les références aux objets du servlet même une fois le servlet terminé.
2. Les détenteurs statiques (tels que les pools de connexions de base de données) conservent les références aux connexions persistantes même si ces connexions ne sont plus nécessaires.
3. L'auditeur n'a pas été supprimé du composant, ce qui a entraîné la conservation de la référence de l'auditeur.

Vous pouvez réduire le risque de fuite de mémoire dans vos applications Java en comprenant les scénarios courants de fuite de mémoire et en adoptant des pratiques de codage appropriées pour garantir leur stabilité et leurs performances.

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!