Utilisez des structures de données efficaces comme ArrayList sur LinkedList et des collections primitives pour réduire les frais généraux; 2. Minimiser la création d'objets en réutilisant des objets, en utilisant StringBuilder pour la concaténation et en mettant en cache des objets co?teux; 3. Empêcher les fuites de mémoire en annulant les références, en utilisant des classes intérieures statiques, en désinscrivant les auditeurs et en utilisant des références faibles / douces dans les caches; 4. Assurez le JVM avec une taille de tas appropriée, sélectionnez des collectionneurs de déchets appropriés (par exemple, G1GC, ZGC), activez la journalisation GC et utilisez des outils de surveillance comme VisualVM ou Prométhée avec micromètre; 5. Optimiser l'utilisation des cordes et des tableaux en évitant les internes inutiles, en étant prudent avec la sous-cha?ne () et la taille des baies de coupe - la gestion efficace de la mémoire en Java nécessite un codage intelligent, des outils appropriés et une conscience JVM pour réduire le désabonnement des objets et améliorer les performances.

Les applications Java peuvent consommer plus de mémoire que nécessaire si elles ne sont pas soigneusement con?ues, conduisant à des problèmes de performances, à des pauses de collecte de déchets plus longues et même à des exceptions OutOfMemoryError . L'optimisation de l'utilisation de la mémoire ne consiste pas seulement à augmenter la taille du tas - il s'agit d'écrire du code efficace et de comprendre comment le JVM gère la mémoire. Voici des stratégies clés pour réduire l'empreinte de la mémoire et améliorer l'efficacité.

1. Utilisez des structures de données appropriées

Le choix de la bonne structure de données peut avoir un impact significatif sur l'utilisation de la mémoire.

• Préférez ArrayList à LinkedList pour la plupart des cas d'utilisation - LinkedList stocke chaque élément dans un n?ud avec des références aux n?uds suivants et précédents, consommant plus de mémoire.
• Utilisez des collections primitives lorsque cela est possible. Les collections Java standard ( List<integer></integer> , Map<string double></string> ) Stocker des objets, qui incluent les frais généraux. Des bibliothèques comme Trove , FastUtil ou Eclipse Collections offrent des collections économes en mémoire pour les primitives (par exemple, TIntArrayList au lieu de ArrayList<integer></integer> ).
• évitez de stocker des données inutiles. Par exemple, utilisez Set au lieu de List si vous n'avez besoin que de l'unicité et que vous ne vous souciez pas de l'ordre.

 // moins efficace
List <Integer> list = new ArrayList <> ();
list.add (42); // Autoboxing: crée un objet entier

// plus efficace (avec Trove)
TintArrayList list = new TintArrayList ();
list.add (42); // Stores Int directement

2. Minimiser la création et réutiliser des objets dans la mesure du possible

Chaque objet créé ajoute de la pression au tas et au collecteur des ordures.

• Réutilisez les objets utilisant des pools d'objets pour des instances co?teuses ou fréquemment créées (par exemple, les connexions de base de données, les threads - bien que les exécuteurs intégrés préfèrent).
• Utilisez des constructeurs ou des modèles de poids mouche lorsque vous traitez des configurations d'objets similaires.
• évitez la concaténation de cha?ne inutile dans les boucles - utilisez à la place StringBuilder .

 // mauvais: crée plusieurs cha?nes intermédiaires
Résultat de cha?ne = "";
pour (String S: cha?nes) {
    résultat = s;
}

// bon: Single StringBuilder
StringBuilder sb = new StringBuilder ();
pour (String S: cha?nes) {
    SB.APPEND (S);
}
Résultat de la cha?ne = sb.toString ();

• Caches d'objets co?teux comme DateFormat , Pattern ou Données de configuration au lieu de les recréer.

3. Contr?ler les durées de vie des objets et éviter les fuites de mémoire

Même les objets inutilisés peuvent s'attarder en mémoire si les références sont involontairement détenues.

• Annuler les références dans les objets à longue durée de vie lorsqu'il n'est plus nécessaire (rarement nécessaire dans le Java moderne mais pertinent dans les caches ou les auditeurs).
• Surveillez les fuites de classe intérieure : les classes intérieures non statiques maintiennent une référence implicite à la classe extérieure. Utilisez des classes intérieures static lorsque cela est possible.
• Les auditeurs non enregistrés (par exemple, événement, modèles d'observateurs) pour éviter l'accumulation.
• Soyez prudent avec les caches - utilisez des références faibles / douces ou des caches bordées (par exemple, Caffeine , Guava Cache ) au lieu de HashMap ordinaire.

 // préfère les références faibles pour les caches
Map <key, faible référence <value>> cache = new hashmap <> ();

• Sources de fuite courantes:
  • Les collections statiques qui poussent indéfiniment
  • Streams ou ressources non clos (utilisez des ressources essai
  • Variables threadlocal dans les serveurs d'application (en particulier avec la mise en commun de threads)

4. Associer la JVM et le surveillant l'utilisation de la mémoire

Même le code bien écrit bénéficie d'une configuration et d'une surveillance JVM appropriées.

• Définissez la taille appropriée du tas :

   -XMS512M -XMX2G

  évitez de régler -Xmx trop élevé - les tas de grandes tas peuvent entra?ner de longues pauses GC.

• Choisissez le bon collecteur de ordures :

  • G1GC (par défaut dans Java 9): bon pour les tas moyens à grands avec des objectifs de temps en pause faible.
  • ZGC ou Shenandoah (Java 11 et 12 respectivement): pour de très gros tas avec des temps de pause ultra-bas (<10 ms).

• Permettre à la journalisation GC d'analyser le comportement:

   -Xlog: GC *, GC Heap = Debug, GC Stats -xlog: GC: /var/log/gc.log

• Utiliser des outils de surveillance:

  • VisualVM , JConsole ou JMC (Contr?le de mission Java) pour une analyse en temps réel.
  • Micromètre Prometheus pour la surveillance de la production.
  • Tas vidanges ( jmap -dump ) analysé avec le tapis Eclipse pour trouver des porcs de mémoire.

---

5. Optimiser l'utilisation de la cha?ne et du tableau

Les cha?nes et les tableaux sont des consommateurs de mémoire communs.

• évitez les string interminants sauf si nécessaire String.intern() stocke les cha?nes dans le permgen / métaspace et peut entra?ner des problèmes de mémoire.
• Utilisez String.substring() soigneusement dans les versions Java plus anciennes (pré-java 7u6): il a partagé le tableau de char sous-jacent. Les versions modernes copient les données.
• Tailles de baies de coupe - ne pré-allosez pas les grandes tableaux à moins que cela ne soit nécessaire. Envisagez d'utiliser ArrayList avec une croissance contr?lée.

---

L'optimisation de la mémoire en Java est un mélange de pratiques de codage intelligentes, d'outillage approprié et de compréhension du comportement JVM. Concentrez-vous sur la réduction du désabonnement des objets, le choix des structures de données efficaces, l'élimination des fuites et la surveillance avec des données réelles. De petits changements peuvent entra?ner de grandes améliorations de l'évolutivité et de la réactivité.

Fondamentalement, il ne s'agit pas d'écrire moins de code - il s'agit de faire compter chaque octet.

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!