Quel est le garbage collector en Java?

Je suis nouveau sur Java et confus au sujet du garbage collector en Java. Que fait-il réellement et quand intervient-il? Veuillez décrire certaines des propriétés du garbage collector en Java.

Le garbage collector est un programme qui s’exécute sur la machine virtuelle Java qui supprime les objects qui ne sont plus utilisés par une application Java. C’est une forme de gestion automatique de la mémoire .

Lorsqu’une application Java typique est en cours d’exécution, elle crée de nouveaux objects, tels que Ssortingng s et File s, mais après un certain temps, ces objects ne sont plus utilisés. Par exemple, regardez le code suivant:

 for (File f : files) { Ssortingng s = f.getName(); } 

Dans le code ci-dessus, le Ssortingng s est créé à chaque itération de la boucle for . Cela signifie qu’à chaque itération, un peu de mémoire est alloué pour créer un object Ssortingng .

En revenant au code, nous pouvons voir qu’une fois qu’une seule itération est exécutée, dans l’itération suivante, l’object Ssortingng qui a été créé dans l’itération précédente n’est plus utilisé – cet object est maintenant considéré comme une “erreur”.

Finalement, nous allons commencer à recevoir beaucoup de déchets, et la mémoire sera utilisée pour les objects qui ne sont plus utilisés. Si cela continue, la machine virtuelle Java finira par manquer d’espace pour créer de nouveaux objects.

C’est là que le ramasse-miettes intervient.

Le ramasse-miettes va chercher des objects qui ne sont plus utilisés et s’en débarrasse, libérant ainsi la mémoire pour que d’autres nouveaux objects puissent utiliser ce morceau de mémoire.

En Java, la gestion de la mémoire est prise en charge par le garbage collector, mais dans d’autres langages tels que C, il est nécessaire d’effectuer la gestion de la mémoire par eux-mêmes en utilisant des fonctions telles que malloc et free . La gestion de la mémoire est une de ces choses faciles à commettre, ce qui peut conduire à ce que l’on appelle des memory leaks – des endroits où la mémoire n’est plus récupérée lorsqu’elle n’est plus utilisée.

Les systèmes de gestion automatique de la mémoire tels que la récupération de la mémoire permettent au programmeur de ne pas trop se préoccuper des problèmes de gestion de la mémoire. Il peut donc se concentrer davantage sur le développement des applications à développer.

Il libère la mémoire allouée aux objects qui ne sont plus utilisés par le programme – d’où le nom “garbage”. Par exemple:

 public static Object otherMethod(Object obj) { return new Object(); } public static void main(Ssortingng[] args) { Object myObj = new Object(); myObj = otherMethod(myObj); // ... more code ... } 

Je sais que cela est extrêmement artificiel, mais ici, après avoir appelé otherMethod() l’ Object origine créé est rendu inaccessible – et c’est de la “poubelle” qui reçoit des déchets.

En Java, le GC s’exécute automatiquement, mais vous pouvez également l’appeler explicitement avec System.gc() et essayer de forcer un ramasse-miettes majeur. Comme Pascal Thivent le souligne, vous ne devriez vraiment pas avoir à faire cela et cela pourrait faire plus de mal que de bien (voir cette question ).

Pour plus d’informations, consultez l’entrée Wikipedia sur la récupération de la mémoire et l’ optimisation du nettoyage de la mémoire (à partir d’Oracle).

Un object devient éligible pour le nettoyage de la mémoire ou GC s’il n’est pas accessible depuis des threads en direct ou par des références statiques.

En d’autres termes, vous pouvez dire qu’un object devient éligible pour la récupération de place si toutes ses références sont nulles. Les dépendances cycliques ne sont pas considérées comme des références, donc si l’object A fait référence à l’object B et que l’object B fait référence à l’object A et qu’elles n’ont aucune autre référence active, les deux objects A et B seront éligibles.


Générations de tas pour la récupération de mémoire –

Les objects Java sont créés dans Heap et Heap est divisé en trois parties ou générations pour les besoins de la récupération de la mémoire en Java, appelés génération Young (New), génération Tenured (Old) et Perm zone du tas.

Java heap space La nouvelle génération est divisée en trois parties appelées espace Eden, espace Survivor 1 et Survivor 2. Lorsqu’un object créé en premier dans heap its est créé dans une nouvelle génération à l’intérieur de l’espace Eden et après une récupération de mémoire mineure si un object survit, il est transféré au survivant 1 puis survivant 2 avant que la récupération de mémoire majeure

L’espace autorisé de Java Heap est l’endroit où la machine virtuelle Java stocke les métadonnées relatives aux classes et aux méthodes, au pool de chaînes et aux détails de niveau de classe.

Générations de tas pour le nettoyage de la mémoire

Reportez-vous ici pour plus d’informations: Collecte des ordures ménagères


Vous ne pouvez pas forcer JVM à exécuter Garbage Collection bien que vous puissiez faire une demande en utilisant la méthode Runtime.gc() ou Runtime.gc() .

Dans java.lang.System

 public static void gc() { Runtime.getRuntime().gc(); } 

Dans java.lang.Runtime

 public native void gc(); // note native method 

Algorithme Mark et Sweep –

Ceci est l’un des algorithmes les plus populaires utilisés par la collecte des ordures. Tout algorithme de récupération de place doit effectuer 2 opérations de base. Premièrement, il devrait être capable de détecter tous les objects inaccessibles et, deuxièmement, il doit récupérer l’espace du tas utilisé par les objects indésirables et rendre l’espace à nouveau disponible pour le programme.

Les opérations ci-dessus sont effectuées par Mark et Sweep Algorithm en deux phases:

  1. Marquer la phase
  2. Phase de balayage

lire ici pour plus de détails – Algorithme Mark et Sweep

garbage collector implique que les objects dont le programme n’a plus besoin sont des “déchets” et peuvent être jetés.

Garbage Collector fait partie de JRE et garantit que les objects non référencés seront libérés de la mémoire.
Il s’exécute généralement lorsque votre application manque de mémoire. AFAIK tient un graphique qui représente les liens entre les objects et les objects isolés peuvent être libérés.
Pour enregistrer les performances des objects actuels regroupés en générations, chaque fois que GC parsing un object et constate qu’il est toujours référencé, son compte de génération incrémenté de 1 (à une valeur maximale maximale de 3 ou 4, je pense) et la nouvelle génération analysée en premier (plus l’object en mémoire est court, plus il est probable qu’il n’est plus nécessaire), donc tous les objects ne sont pas scannés à chaque fois que le GC est exécuté.
lisez ceci pour plus d’informations.

Le garbage collector permet à votre ordinateur de simuler un ordinateur avec une mémoire infinie. Le rest n’est que mécanisme.

Pour ce faire, il détecte lorsque des segments de mémoire ne sont plus accessibles à partir de votre code et les renvoie au magasin gratuit.

EDIT: Oui, le lien est pour C #, mais C # et Java sont identiques à cet égard.

Beaucoup de gens pensent que la collecte des ordures recueille et élimine les objects morts.
En réalité, le nettoyage de la mémoire Java fait le contraire! Les objects en direct sont suivis et tout le rest est désigné comme des déchets.

Lorsqu’un object n’est plus utilisé, le récupérateur de mémoire récupère la mémoire sous-jacente et la réutilise pour une future allocation d’object. Cela signifie qu’il n’y a pas de suppression explicite et qu’aucune mémoire n’est restituée au système d’exploitation. Pour déterminer quels objects ne sont plus utilisés, la JVM exécute de manière intermittente ce que l’on appelle très justement un algorithme mark-and-sweep.

Vérifiez cela pour plus d’informations détaillées: http://javabook.compuware.com/content/memory/how-garbage-collection-works.aspx

Le nettoyage de la mémoire en Java (et dans d’autres langages / plates-formes) permet à l’environnement d’exécution Java (JRE) de réutiliser la mémoire d’objects Java inutiles. De manière simpliste, lorsque le JRE démarre initialement, il demande au système d’exploitation (O / S) une certaine quantité de mémoire. Lorsque JRE exécute vos applications, il utilise cette mémoire. Lorsque votre application est faite en utilisant cette mémoire, le “Garbage Collector” de JRE est livré et récupère cette mémoire pour une utilisation par différentes parties de vos applications existantes. Le “Garbage Collector” de JRE est une tâche en arrière-plan qui est toujours en cours d’exécution et qui tente de sélectionner les moments où le système est inactif pour pouvoir être utilisé.

Une analogie réelle serait celle des éboueurs qui viennent chez vous et ramassent vos déchets recyclables … éventuellement, vous les utilisez à votre guise et / ou d’autres personnes.

Le garbage collector peut être vu comme un gestionnaire de compte de référence. Si un object est créé et que sa référence est stockée dans une variable, son compte de référence est augmenté de un. au cours de l’exécution si cette variable est assignée avec NULL. le compte de référence pour cet object est décrémenté. Le compte de référence actuel de l’object est donc 0. Désormais, lorsque le récupérateur de place est exécuté, il recherche les objects avec le nombre de références 0 et libère les ressources qui lui sont allouées.

L’invocation du collecteur de place est contrôlée par les stratégies de récupération de place.

Vous pouvez obtenir des données ici. http://www.oracle.com/technetwork/java/gc-tuning-5-138395.html

Le garbage collector est un composant de jvm.

Il est utilisé pour collecter les ordures lorsque le processeur est libéré.

Ici, les ordures sont des objects non utilisés qu’il exécute en arrière-plan du programme principal

surveiller l’état du programme principal.

Le nettoyage automatique des ordures consiste à examiner la mémoire du tas, à identifier les objects utilisés et ceux qui ne le sont pas et à supprimer les objects inutilisés. Un object in use, ou un object référencé, signifie qu’une partie de votre programme conserve toujours un pointeur sur cet object. Un object non utilisé, ou un object non référencé, n’est plus référencé par aucune partie de votre programme. Ainsi, la mémoire utilisée par un object non référencé peut être récupérée.

Dans un langage de programmation comme C, allouer et désallouer de la mémoire est un processus manuel. En Java, le processus de désallocation de mémoire est géré automatiquement par le garbage collector. S’il vous plaît vérifier le lien pour une meilleure compréhension. http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html

Le nettoyage de la mémoire fait référence au processus de libération automatique de la mémoire sur le tas en supprimant les objects qui ne sont plus accessibles dans votre programme. Le tas est une mémoire appelée magasin libre, qui représente un grand pool de mémoire inutilisée allouée à votre application Java.

Les principes de base de la récupération de place consistent à rechercher des objects de données dans un programme inaccessible ultérieurement et à récupérer les ressources utilisées par ces objects. https://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29

Avantages

1) Sauvegarde des bugs, qui se produisent quand un morceau de mémoire est libéré alors qu’il ya encore des pointeurs vers lui, et l’un de ces pointeurs est déréférencé. https://en.wikipedia.org/wiki/Dangling_pointer

2) Double bogues libres, qui se produisent lorsque le programme essaie de libérer une région de mémoire qui a déjà été libérée et peut-être déjà de nouveau allouée.

3) Empêche certains types de memory leaks, dans lesquelles un programme ne parvient pas à libérer de la mémoire occupée par des objects devenus inaccessibles, ce qui peut entraîner un épuisement de la mémoire.

Désavantages

1) Consumr des ressources supplémentaires, des impacts sur les performances, des blocages possibles dans l’exécution du programme et des incompatibilités avec la gestion manuelle des ressources. La récupération de la mémoire consum des ressources informatiques pour décider de la mémoire à libérer, même si le programmeur a déjà connu cette information.

2) Le moment où la poubelle est effectivement collectée peut être imprévisible, ce qui entraîne des stalles (des pauses pour déplacer / libérer de la mémoire) dispersées tout au long d’une session. Les décrochages imprévisibles peuvent être inacceptables dans les environnements en temps réel, dans le traitement des transactions ou dans les programmes interactifs.


Tutoriel Oracle http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html

Le nettoyage de la mémoire est le processus qui identifie les objects en cours d’utilisation et ceux qui ne le sont pas, et supprime les objects inutilisés.

Dans un langage de programmation tel que C, C ++, allouer et libérer de la mémoire est un processus manuel.

 int * array = new int[size]; processArray(array); //do some work. delete array; //Free memory 

La première étape du processus s’appelle le marquage. C’est là que le ramasse-miette identifie les morceaux de mémoire utilisés et ceux qui ne le sont pas.

Étape 2a. La suppression normale supprime les objects non référencés en laissant des objects et des pointeurs référencés à l’espace libre.

Pour améliorer les performances, nous souhaitons supprimer les objects non référencés et compacter également les objects référencés restants. Nous voulons garder les objects référencés ensemble, il sera donc plus rapide d’allouer de nouvelles mémoires.

Comme indiqué précédemment, le fait de devoir marquer et compacter tous les objects dans une machine virtuelle Java est inefficace. Au fur et à mesure que de plus en plus d’objects sont alloués, la liste des objects augmente et augmente le temps de récupération de la mémoire.

Continuez à lire ce tutoriel, et vous saurez comment GC relève ce défi.

En bref, il existe trois régions du tas, YoungGeneration pour les objects à durée de vie courte, OldGeneration pour les objects à période longue et PermanentGeneration pour les objects qui vivent pendant la durée de vie de l’application, par exemple, les classes et les bibliothèques.

Comme les objects sont alloués dynamicment par le nouvel opérateur, vous pouvez demander comment ces objects sont détruits et comment la mémoire occupée est libérée. Dans d’autres langages tels que C ++, vous devez libérer dynamicment les objects alloués manuellement par l’opérateur de suppression. Java a une approche différente. Gère automatiquement la désallocation. La technique est connue sous le nom de collecte de déchets .

Cela fonctionne comme ceci: quand il n’y a pas de références à un object, il est supposé que cet object n’est plus nécessaire et que vous pouvez récupérer la mémoire occupée par l’object. Il n’est pas nécessaire de détruire explicitement des objects comme en C ++. La récupération de la mémoire se produit sporadiquement lors de l’exécution du programme. Cela ne se produit pas simplement parce qu’il y a un ou plusieurs objects qui ne sont plus utilisés. En outre, plusieurs implémentations d’exécution Java ont des approches différentes de la récupération de la mémoire, mais la plupart des programmeurs n’ont pas à se soucier de l’écriture de programmes.

Un object devient éligible pour le nettoyage de la mémoire ou GC s’il n’est pas accessible depuis des threads en direct ou par des références statiques.

En d’autres termes, vous pouvez dire qu’un object devient éligible pour la récupération de place si toutes ses références sont nulles. Les dépendances cycliques ne sont pas considérées comme des références, donc si l’object A fait référence à l’object B et que l’object B fait référence à l’object A et qu’elles n’ont aucune autre référence active, les deux objects A et B seront éligibles.


Générations de tas pour la récupération de mémoire –

Les objects Java sont créés dans Heap et Heap est divisé en trois parties ou générations pour les besoins de la récupération de la mémoire en Java, appelés génération Young (New), génération Tenured (Old) et Perm zone du tas.

Java heap space La nouvelle génération est divisée en trois parties appelées espace Eden, espace Survivor 1 et Survivor 2. Lorsqu’un object créé en premier dans heap its est créé dans une nouvelle génération à l’intérieur de l’espace Eden et après une récupération de mémoire mineure si un object survit, il est transféré au survivant 1 puis survivant 2 avant que la récupération de mémoire majeure

L’espace autorisé de Java Heap est l’endroit où la machine virtuelle Java stocke les métadonnées relatives aux classes et aux méthodes, au pool de chaînes et aux détails de niveau de classe.

Générations de tas pour le nettoyage de la mémoire

Pour le dire en termes simples que même un non-programmeur peut comprendre, lorsqu’un programme traite des données, il crée des données intermédiaires et de l’espace de stockage (variables, tableaux, certaines métadonnées d’object, etc.) pour ces données.

Lorsque ces objects sont accessibles à travers des fonctions ou sur une certaine taille, ils sont atsortingbués à partir d’un segment de mémoire central. Ensuite, quand ils ne sont plus nécessaires, ils doivent être nettoyés.

Il y a de très bons articles en ligne sur la façon dont cela fonctionne, alors je vais juste couvrir la définition très simple.

Le GC est essentiellement la fonction qui effectue ce nettoyage. Pour ce faire, efface les entrées de table qui ne sont référencées par aucun object actif, en supprimant efficacement les objects, que de copier et de compacter la mémoire. C’est un peu plus compliqué que ça, mais vous avez l’idée.

Le gros problème réside dans le fait que ce processus nécessite souvent l’arrêt temporaire de l’ensemble de la machine virtuelle Java, et que ce processus nécessite beaucoup de bande passante en termes de processeur et de mémoire. Les différentes options de GC et les options de réglage pour chacune sont conçues pour équilibrer ces différents problèmes avec l’ensemble du processus de GC.

La récupération automatique de la mémoire est un processus par lequel la machine virtuelle Java supprime ou conserve certains points de données en mémoire pour libérer de l’espace pour le programme en cours d’exécution. La mémoire est d’abord envoyée à la mémoire tas, c’est-à-dire que le ramasse-miettes (GC) fait son travail, puis décide de le terminer ou de le conserver. Java suppose que le programmeur ne peut pas toujours être approuvé, donc il met fin aux éléments dont il pense ne pas avoir besoin.