Mémoire et concurrence
La gestion de la concurrence (multi-processus léger) et de la mémoire sont étroitement lié dans la plate-forme Java. Elles implique : l'algorithme du ramasse-miettes (Garbage Collection) de base avec marquage et balayage, le JVM HotSpot optimisé pour le ramasse-miettes en fonction de la durée de vie de l'objet, les primitives de concurrence de Java et la visibilité et mutabilité des données.
Concepts de base de la gestion de la mémoire Java
En Java, la mémoire occupée par un objet est automatiquement récupérée lorsque l'objet n'est plus nécessaire. Cette situation se fait via un processus connu sous le nom de ramasse-miettes (ou gestion automatique de la mémoire). Le ramasse-miettes est une technique existant depuis des années dans des langages de programmation comme Lisp. Il faut un certain temps pour s'y habituer pour les programmeurs habitués aux langages tels que C et C++, dans lesquels vous devez appeler la fonction free() ou l'opérateur delete pour récupérer de la mémoire.
Le fait que vous n'ayez pas besoin de vous rappeler de détruire chaque objet que vous créez est l'une des fonctionnalités faisan de Java un langage de programmation agréable à utiliser. C'est également l'une des fonctionnalités rendant les programmes écrits en Java moins sujets aux bogues que ceux écrits dans des langages ne prenant pas en charge le ramasse-miettes automatiquement.
Différentes mises en oeuvre de VM gèrent le ramasse-miettes de différentes manières, et les spécifications n'imposent pas de restrictions très strictes sur la façon dont ramasse-miettes doit être mise en oeuvre. Bien que ce ne soit pas la seule JVM que vous puissiez rencontrer, comme par exemple la JRockit, l'OpenJ9 et l'IBM J9, la JVM HotSpot (étant à la base des mise en oeuvre Oracle et OpenJDK de Java), est la plus courante parmi les déploiements côté serveur et fournit un bon exemple de JVM de production moderne.
Fuites de mémoire à Java
Le fait que Java prenne en charge le ramasse-miettes réduit considérablement les signes de fuites de mémoire. Une fuite de mémoire se produit lorsque la mémoire est allouée et jamais réutilisé. À première vue, il peut sembler que le ramasse-miettes empêche toutes les fuites de mémoire car il récupère tous les objets inutilisés. Une fuite de mémoire peut néanmoins se produire en Java, si une référence valide (mais non utilisée) à un objet inutilisé est laissée en suspens. Par exemple, lorsqu'une méthode s'exécute pendant une longue période (ou pour toujours), les variables locales de la méthode peuvent conserver les références d'objet beaucoup plus longtemps qu'elles ne sont réellement nécessaires. Le code suivant en est un exemple :
- class MemoryLeakSamples {
- public static int calcul(int valeur[]) {
- if(valeur[0] == 1) ;
- /* ... */
- return 0;
- }
-
- public static void gestionnaire_entree(int valeur) {
- /* ... */
- }
-
- public static void main(String args[]) {
- int grosTableau[] = new int[100000];
- int resultat = calcul(grosTableau);
- /* ... */
- grosTableau = null;
- /* ... */
- for(;;) gestionnaire_entree(resultat);
- }
- }
Des fuites de mémoire peuvent également se produire lorsque vous utilisez un HashMap ou une structure de données similaire pour associer un objet à un autre. Même si aucun des deux objets n'est requis, associer un objet à un autre, l'association reste dans la table de hachage, empêchant les objets d'avoir une durée de vie plus longue que les objets qu'il contient, ainsi il peut provoquer des fuites de mémoire.
Présentation du Mark-and-Sweep
Pour expliquer la forme de base de l'algorithme Mark-and-Sweep apparaîssant dans la JVM, supposons qu'il existe deux structures de données de base que la JVM gère. Ceux-ci sont : Tableau d'allocation (entrepose les références à tous les objets (et tableaux) ayant été alloués et non encore collectés), une liste libre (contenant une liste de blocs de mémoire libres et disponibles pour allocation). Avec ces définitions, il est maintenant évident quand le ramasse-miettes doit se produire; il est nécessaire lorsqu'un processus léger Java tente d'allouer un objet (via l'opérateur new) et que la liste libre ne contient pas un bloc de taille suffisante. Notez également que la JVM garde la trace des informations de type sur toutes les allocations et peut ainsi déterminer quelles variables locales dans chaque cadre de pile font référence à quels objets et tableaux dans le mémoire de tas. En suivant les références détenues par les objets et les tableaux dans la mémoire de tas, la machine virtuelle Java peut tracer et trouver tous les objets et tableaux auxquels il est toujours fait référence, même indirectement.
Ainsi, l'environnement d'exécution est capable de déterminer quand un objet alloué n'est plus référencé par aucun autre objet ou variable actif. Lorsque l'interpréteur trouve un tel objet, il sait qu'il peut récupérer en toute sécurité la mémoire de l'objet et le fait. Notez que le ramasse-miettes peut également détecter et récupérer des objets de cycles se référant les uns aux autres, mais n'étant pas référencés par aucun autre objet actif. Nous définissons un objet accessible comme étant un objet pouvant être atteint en commençant à partir d'une variable locale dans l'une des méthodes de la trace de pile d'un processus léger d'application, et en suivant les références jusqu'à ce que vous atteigniez l'objet. On dit également que les objets de ce type sont en vie.