Les champs statiques détenant des références d'objets peuvent empêcher la collecte des ordures; Corrigez en utilisant WaiwhashMap ou en mettant en ?uvre l'expulsion. 2. Une mauvaise utilisation des auditeurs et des rappels peut conserver inutilement des objets; Correction par les auditeurs non enregistrés ou en utilisant des références faibles et des classes intérieures statiques. 3. Les ressources non cl?turées comme les flux ou les connexions maintiennent la mémoire native; Corrigez en utilisant des ressources TRY-With pour le nettoyage automatique. 4. Les classes intérieures non statiques conservent des références aux instances extérieures, bloquant la collection de déchets; réparer en les rendant statiques ou en utilisant des références faibles. 5. Les caches sans expulsion se développent indéfiniment; Corrigez en utilisant des bibliothèques de cache gérées comme la caféine ou Ehcache avec la taille et les limites de temps. 6. Les variables threadlocal peuvent fuir lorsque les threads sont réutilisés; Correction en appelant toujours enlèvement () dans un bloc enfin. 7. Des fuites de chargeur de classe se produisent pendant le redéploiement si les références de classe ancienne persistent; Correction en évitant les références statiques et en arrêtant des threads créés par l'application. Pour éviter les fuites, évitez les collections statiques à longue durée de vie, utilisez les références faibles de manière appropriée, nettoyez les filetages, préfèrent les classes internes statiques, fermez des ressources avec des ressources try-with et surveillez la mémoire avec des outils tels que VisualVM ou JProfiler, car les fuites de mémoire Java sont souvent subtiles et émergent au fil du temps.

Les fuites de mémoire en Java sont moins courantes que dans les langues sans collecte de déchets, mais elles se produisent toujours, en particulier dans les applications de longue durée. étant donné que le JVM récupére automatiquement les objets inutilisés, les fuites de mémoire découlent généralement de la rétention d'objets involontaires , où les objets sont toujours accessibles et donc non collectés, même s'ils ne sont plus nécessaires.

Voici les causes les plus courantes:

1. Champs statiques contenant des références d'objets

Les champs statiques vivent pour la durée de vie de la demande à moins d'être effacés explicitement. Si une collection statique (comme une List , Map ou un cache) contient des références à des objets, ces objets ne seront pas collectés des ordures, même s'ils ne sont plus utilisés.

 classe publique Cache {
    Map statique privé <cha?ne, objet> cache = new HashMap <> ();

    public static void addTocache (clé de cha?ne, valeur d&#39;objet) {
        cache.put (clé, valeur); // Les objets s&#39;accumulent et ne sont jamais supprimés
    }
}

?? Fix : Utilisez WeakHashMap pour les caches le cas échéant, ou implémentez une stratégie de nettoyage (par exemple, expulsion basée sur le temps).

2. Utilisation incorrecte des auditeurs et des rappels

Les auditeurs d'événements (par exemple, dans les applications GUI ou les modèles d'observateurs) sont souvent enregistrés mais non inscrits. Si l'auditeur détient une référence à un grand objet (ou si l'auditeur lui-même est une classe intérieure non statique), elle peut empêcher la collecte des ordures.

 Button.AddListener (new ActionListener () {
    public void ActionPerformed (ActionEvent e) {
        // La classe intérieure anonyme tient une référence à l'instance d'enfermement
    }
});

?? Correction : non enregistrer les auditeurs lorsqu'il n'est plus nécessaire. Utilisez des références faibles ou faites des écouteurs des classes intérieures statiques si elles n'ont pas besoin d'accéder à l'instance extérieure.

3. Ressources non cl?turées (E / S, flux, connexions)

Bien qu'il ne s'agisse pas toujours d'une fuite de mémoire directe, des ressources non cl?turées comme InputStream , ResultSet , Socket ou Connection peuvent maintenir la mémoire native ou des tampons internes, conduisant à l'épuisement des ressources et à la pression de la mémoire indirecte.

 FileInputStream fis = new FileInputStream ("file.txt");
// oublié de fermer () - la poignée de fichiers et le tampon restent alloués

?? Correction : utilisez toujours des ressources essai-avec:

 try (fileInputStream fis = new FileInputStream ("file.txt")) {
    // fermé automatique
}

4. Classes intérieures tenant des références extérieures

Les classes intérieures non statiques maintiennent une référence à leur instance de classe entourée. Si l'objet de classe intérieure (par exemple, une tache de thread ou de minuterie à longue durée de vie) survit à l'objet extérieur, il empêche l'objet extérieur d'être collecté.

 classe publique extérieure {
    private int [] data = new int [1000000];

    public void startTask () {
        nouveau thread (new Runnable () {
            public void run () {
                // Cet runnable détient une référence à l'instance ?extérieure?
                // Même si l'extérieur n'est plus nécessaire, il ne peut pas être gc'd
            }
        }).commencer();
    }
}

?? Correction : rendez la classe intérieure static ou utilisez WeakReference<Outer> si un accès extérieur est nécessaire.

5. Caches sans expulsion appropriée

Les caches en mémoire personnalisées qui se développent indéfiniment (par exemple, le stockage des séances utilisateur ou des résultats calculés) sont une source classique de fuites de mémoire.

?? Fix : Utilisez des bibliothèques de cache comme la caféine ou l'Ehcache qui prennent en charge les limites de taille, le temps de vivre (TTL) et les références faibles / douces.

6. Variables threadlocales

Les variables ThreadLocal sont pratiques pour l'état par thread, mais ils peuvent fuir la mémoire, en particulier dans des environnements avec un accumulation de threads (comme des serveurs Web). Si un thread est réutilisé mais que le ThreadLocal n'est pas effacé, la valeur reste en mémoire.

 Final Final statique privé <MyObject> local = new ThreadLocal <> ();

?? Correction : appelez toujours remove() une fois terminé:

 essayer {
    local.set (SomeValue);
    // ... travaillez
} enfin {
    local.remove (); // Critique!
}

7. Fuites de chargeur de classe

Dans les serveurs d'applications ou les environnements OSGI, le redéploiement d'une application sans décharger complètement les anciennes classes peut provoquer des fuites de ClassLoader . Cela se produit lorsque les classes chargées par l'ancien ClassLoader sont toujours référencées (par exemple, via des champs statiques, des threads ou JNI).

?? Correction : évitez les références statiques aux classes d'application. Assurez-vous que les threads créés par l'application sont arrêtés sur Undeploy.

Résumé des principaux conseils de prévention:

• évitez les collections statiques à longue durée de vie, sauf bien gérées.
• Utilisez des références faibles ( WeakHashMap , WeakReference ) pour les caches ou les auditeurs.
• Nettoyez les valeurs ThreadLocal .
• Préférez les classes intérieures static pour éviter les références extérieures accidentelles.
• Utilisez des ressources TRY-With pour toutes les ressources cl?turées.
• Surveillez l'utilisation du tas avec des outils tels que VisualVM , Eclipse Mat ou JProfiler .

Les fuites de mémoire en Java sont souvent subtiles et n'apparaissent que sous la charge ou au fil du temps - une conception et une surveillance proactives sont donc essentielles.

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!