FUITES MEMOIRE ET ERREURS COURRANTES

a-les fuites de mémoire

Il existe plusieurs types de fuites de mémoire : fuites d'unité d'exécution et ThreadLocal, fuites
ClassLoader, fuites de ressource système et fuites de connexion. Les approches de détection des
fuites de mémoire impliquent généralement l'examen des compteurs JVMTI (Java virtual
machine tool Interface) ou PMI (Performance Monitoring Infrastructure) pour surveiller la
croissance lente de l'utilisation du segment de mémoire Java ou natif.

Fuite de mémoire de chargeur de classe

La plupart des fuites de mémoire se présentent sous forme de fuites de chargeur de classe. Une
classe Java est identifiée de manière un ique par son nom et par le chargeur de classe qui l'a
chargée. Les classes du même nom peuvent être chargées plusieurs fois dans une machine
virtuelle Java unique, chacune dans un chargeur de classe différent. Chaque application Web
obtient son propre chargeur de classe et c'est ce que WebSphere Application Server utilise pour
isoler les applications.

Un objet détient une référence à la classe dont elle est l'instance. Une classe détient une référence
au chargeur de classe qui l'a chargée. Le chargeur de classe détient une référence à chaque classe
qu'il a chargée. La détention d'une référence à un objet unique à partir d'une application Web
identifie chaque classe chargée par l'application Web. Ces références sont généralement
conservées après le rechargement d'une application Web. Avec chaque rechargement, des classes
supplémentaires sont identifiées, ce qui conduit à une erreur d'insuffisance de mémoire.

Les fuites de mémoire de chargeur de classe sont généralement occasionnées par le code
d'application ou le code JRE.

Fuites déclenchées par le code JRE

Des fuites de mémoire se produisent lorsque le code de l'environnement d'exécution Java (JRE)
utilise le chargeur de classe de contexte pour charger un singleton d'application. Ces singletons
peuvent être des unités d'exécution ou d'autres objets chargés par le JRE à l'aide du chargeur de
classe de contexte.

Si le code d'application Web déclenche l'initialisation d'un singleton ou d'un initialiseur statique,
les conditions suivantes s'appliquent :

 Le chargeur de classe de contexte devient le chargeur de classe d'application Web.

 Une référence au chargeur de classe d'application Web est créée. Cette référence ne fait
jamais l'objet d'une récupération de place.
 Fixe en mémoire le chargeur de classe et toutes les classes qu'il charge.

Fuites déclenchées par l'application

Les catégories de fuites déclenchées par l'application sont les suivantes :

 Classe ThreadLocal personnalisée

 Instance de classe d'application Web sous forme de valeur ThreadLocal
 Instance de classe d'application Web détenue indirectement par le biais d'une valeur
ThreadLocal
 Pseudo-fuite ThreadLocal
 ContextClassLoader et unités d'exécution créées par des applications Web
 ContextClassLoader et unités d'exécution créées par des classes chargées par le chargeur
de classe commun
 Variables de classe statiques
 Enregistrement de pilote JDBC : cibles RMI

Tableau récapitulatif des corrections de fuite

Cause de la fuite Procedure de correction

Thread local Renouvelez les unités d'exécution du pool
d'unités d'exécution pendant une période
configurable. L'extraction des unités
d'exécution du pool permet aux unités

Unités d'exécution persistantes HttpClient
Unités d'exécution de compteur
Unités d'exécution non contrôlées par la
machine virtuelle Java
Pilotes JDBC
ResourceBundle
Cibles RMI
Variables de classe statiques
b-Les erreurs courantes
1. Utilisation incorrecte des boucles:
d'exécution et aux threadlocals de récupérer
de la place.
Faites basculer l'unité d'exécution sur le
chargeur de classe parent
Utilisez le mécanisme de réflexion pour
arrêter les nouvelles tâches éventuellement
planifiées.
Si l'unité d'exécution est démarrée à l'aide
d'un programme d'exécution, arrêtez ce
dernier ou interrompez l'unité d'exécution.
Annulez l'enregistrement des pilotes JDBC
qui sont enregistrés par l'application Web et
oubliés par celle-ci.
Effacez la mémoire cache ResourceBundle
des ensembles chargés par ce chargeur de
classe ou n'importe quel chargeur de classe
dont ce chargeur est un chargeur de classe
parent.
Utilisez le mécanisme de réflexion pour
effacer les valeurs dans
sun.rmi.transport.ObjectTable.implTable et
sun.rmi.transport.ObjectTable.objTable.
WebSphere Application Server annule la
valeur de toutes les variables de classe
statique des classes chargées par le chargeur
de classe de l'application ou du module.
Dans cet exemple, la boucle for va imprimer les nombres de 0 à 10 inclus. Cependant, si
l'intention était d'imprimer les nombres de 0 à 9, la condition devrait être i < 10 au lieu de i <=
10.

2. Comparaison d'objets avec l'opérateur d'égalité:

Dans cet exemple, les objets str1 et str2 sont comparés avec l'opérateur d'égalité (==), ce qui
compare les références mémoire et non les valeurs des objets. Pour comparer le contenu des
chaînes, il faut utiliser la méthode equals().

3. Utilisation incorrecte des opérateurs logiques:

Dans cet exemple, l'opérateur logique && est utilisé pour vérifier si x et y sont tous deux positifs.
Cependant, si l'intention était de vérifier si au moins l'un des nombres est positif, il faudrait
utiliser l'opérateur logique ||.

4. Déclaration incorrecte de variables:

Dans cet exemple, la variable x est déclarée mais n'est pas initialisée avant d'être utilisée dans
l'instruction System.out.println(). Cela entraînera une erreur de compilation car les variables
locales doivent être initialisées avant leur utilisation.

5. Utilisation incorrecte des tableaux:

Dans cet exemple, un tableau est déclaré avec trois éléments mais lorsqu'on essaie d'accéder à
l'élément à l'index 3 (qui n'existe pas), une erreur d'exécution
(ArrayIndexOutOfBoundsException) sera levée.

7. « Bretelles » manquantes

Laisser des accolades {} dans la ligne de codes tels que ( { et } ) peut conduire à un résultat
désastreux. Cela arrive souvent lorsqu’un développeur oublie de mettre une accolade ouverte et
exécute le code et que les développeurs au niveau débutant commettent ces erreurs si souvent au
cours de leur période initiale. Cependant, les IDE et les compilateurs peuvent identifier ces
petites erreurs, mais il faut veiller à garder un œil attentif lors de l’ouverture des accolades et à les
fermer immédiatement lors du passage à la section de code suivante.

Nous résumons ceci en disant que Les erreurs courantes en Java sont des erreurs de
programmation qui peuvent survenir lors du développement d'applications en Java. Ces erreurs
peuvent causer des dysfonctionnements dans le programme et affecter sa performance. Il est
important de les identifier et de les corriger rapidement pour garantir le bon fonctionnement de
l'application. EN plus des exemples cités plus haut

Voici une autre liste des erreurs courantes en Java :

1. Erreur de syntaxe : Les erreurs de syntaxe sont des erreurs qui surviennent lorsque le code
Java ne respecte pas la syntaxe du langage. Cela peut inclure des fautes de frappe, des
parenthèses manquantes ou mal placées, des points-virgules oubliés, etc.

2. Erreur de logique : Les erreurs de logique sont des erreurs qui surviennent lorsque la
logique du programme est incorrecte. Cela peut se produire lorsque les conditions d'une
boucle ou d'une instruction if ne sont pas correctement définies, ce qui entraîne un
comportement inattendu du programme.

3. Erreur de type : Les erreurs de type surviennent lorsque un objet est utilisé avec un type
incorrect. Par exemple, essayer d'appeler une méthode sur un objet qui n'a pas cette
méthode définie entraînera une erreur de type.

4. Erreur de dépassement : Les erreurs de dépassement se produisent lorsqu'un programme

tente d'accéder à une zone mémoire en dehors des limites autorisées. Cela peut entraîner
un plantage du programme ou un comportement imprévisible.

5. Erreur NullPointerException : L'erreur NullPointerException se produit lorsqu'un

programme tente d'accéder à un objet null, c'est-à-dire un objet qui n'a pas été initialisé
correctement. Cela peut se produire lorsqu'un objet n'a pas été instancié avant son
utilisation.
6. Erreur d'index hors limites : Cette erreur se produit lorsqu'un programme tente d'accéder à
un élément dans un tableau en utilisant un index qui est en dehors des limites du tableau.

7. Erreur de concurrence : Les erreurs de concurrence surviennent lorsqu'il y a plusieurs

threads en cours d'exécution et qu'ils accèdent simultanément à des ressources partagées
sans synchronisation appropriée. Cela peut entraîner des problèmes tels que les conditions
de course et les deadlocks.