Quel est le ramasse-miettes en Java?
Je suis nouveau sur Java et je ne comprends pas ce qu'est le ramasse-miettes en Java. Que fait-il réellement et quand est-ce qu'il entre en action? Veuillez décrire certaines propriétés du ramasse-miettes en Java.
garbage collector est un programme qui s'exécute sur la Java Virtual Machine qui supprime les objets qui ne sont pas utilisés par une Java application). C’est une forme de gestion automatique de la mémoire .
Lorsqu'une application typique Java est en cours d'exécution, elle crée de nouveaux objets, tels que Strings et Files, mais après un certain temps, ces objets ne sont plus utilisés. Par exemple, jetez un coup d’œil au code suivant:
for (File f : files) {
String s = f.getName();
}
Dans le code ci-dessus, le String 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 objet String.
En revenant au code, nous pouvons voir qu’une fois qu’une seule itération est exécutée, lors de la prochaine itération, l’objet String créé lors de la précédente itération n’est plus utilisé, cet objet est maintenant considéré " des ordures".
Finalement, nous allons commencer à avoir beaucoup de déchets, et la mémoire sera utilisée pour les objets qui ne sont plus utilisés. Si cela continue, la machine virtuelle Java) manquera d’espace pour créer de nouveaux objets.
C'est là que le ramasse-miettes intervient.
Le ramasse-miettes va rechercher les objets qui ne sont plus utilisés, et s'en débarrasse, en libérant de la mémoire pour que d'autres nouveaux objets puissent utiliser ce morceau de mémoire.
En Java, le ramasse-miettes s’occupe de la gestion de la mémoire, mais dans d’autres langages tels que le C, il est nécessaire de gérer lui-même la mémoire à l’aide de fonctions telles que malloc et free . Gestion de la mémoire est l'une de ces choses qui sont faciles à commettre des erreurs, ce qui peut conduire à ce qu'on appelle fuites de mémoire - des endroits où la mémoire n'est pas récupérée quand ils ne sont pas dedans utiliser plus.
Les systèmes de gestion de la mémoire automatiques tels que la récupération de place permettent au programmeur de ne pas trop se soucier de la gestion de la mémoire, de sorte qu'il peut se concentrer davantage sur le développement des applications dont il a besoin.
Il libère la mémoire allouée aux objets 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(String[] args) {
Object myObj = new Object();
myObj = otherMethod(myObj);
// ... more code ...
}
Je sais que cela est extrêmement artificiel, mais voici que vous appelez otherMethod() l'original Object créé est rendu inaccessible - et c'est un "déchet" qui est récupéré.
Dans Java, le CPG s'exécute automatiquement, mais vous pouvez également l'appeler explicitement avec System.gc() et essayez de: force une importante collecte de déchets. Comme Pascal Thivent le fait remarquer, vous ne devriez pas avoir à faire ceci et cela pourrait faire plus de mal que de bien (voir cette question ).
Pour plus d'informations, voir l'entrée de Wikipédia sur Collecte des ordures et Réglage de la collecte des ordures (à partir d'Oracle)
Un objet devient éligible pour le Garbage collection ou GC s'il n'est pas accessible à partir de threads en direct ou de références statiques.
En d'autres termes, vous pouvez dire qu'un objet devient éligible pour le garbage collection si toutes ses références sont nulles. Les dépendances cycliques ne sont pas comptées comme référence. Par conséquent, si l'objet A a une référence à l'objet B et que l'objet B a une référence à l'objet A et qu'ils n'ont pas d'autre référence active, les objets A et B seront éligibles pour la récupération de place.
Générations de tas pour la récupération de place -
Les objets Java sont créés dans Heap et Heap est divisé en trois parties ou générations afin de faciliter la récupération de place en Java, elles sont appelées ainsi Jeune (nouvelle) génération, tenure (ancienne) génération et zone permanente du segment de mémoire.
La nouvelle génération est ensuite divisée en trois parties appelées espace Eden, espace Survivor 1 et espace Survivor 2. Lorsqu'un objet créé pour la première fois dans le tas, il est créé dans une nouvelle génération dans l'espace Eden et après la récupération mineure ultérieure, si un objet survit, il est déplacé vers le survivant 1, puis le survivant 2 avant que le nettoyage principal ne déplace cet objet vers génération ancienne ou permanente .
Espace permanent de Java Le segment de mémoire est l'endroit où la machine virtuelle Java stocke les métadonnées sur les classes et les méthodes, le pool de chaînes et les détails au niveau de la classe.
Reportez-vous ici pour plus d'informations: Garbage Collection
Vous ne pouvez pas forcer JVM à exécuter Garbage Collection, mais vous pouvez également effectuer une demande à l'aide de la méthode System.gc() ou Runtime.gc().
public static void gc() {
Runtime.getRuntime().gc();
}
public native void gc(); // note native method
Algorithme de marquage et de balayage -
C'est l'un des algorithmes les plus populaires utilisés par Garbage Collection. 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 objets inaccessibles et, deuxièmement, il doit récupérer l’espace de tas utilisé par les objets parasites et le rendre à nouveau disponible pour le programme.
Les opérations ci-dessus sont effectuées par Mark and Sweep Algorithm en deux phases:
- Phase de marquage
- Phase de balayage
lisez ici pour plus de détails - Algorithme Mark and Sweep
garbage collector implique que les objets dont le programme n'a plus besoin sont des "ordures" et peuvent être jetés.
Garbage Collector fait partie de JRE et garantit que les objets 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. Autant que je sache, il contient un graphique qui représente les liens entre les objets et les objets isolés peuvent être libérés.
Pour enregistrer les performances des objets actuels regroupés en générations, chaque fois que GC analyse un objet et constate qu’il est toujours référencé, son nombre de générations est incrémenté de 1 (jusqu’à une valeur maximale maximale de 3 ou 4, je pense), et le les nouvelles générations sont analysées en premier (plus l’objet en mémoire est court, plus il n’est probablement plus nécessaire), de sorte que tous les objets ne sont pas analysés à chaque exécution du CPG.
read this pour plus d'informations.
Beaucoup de gens pensent que le ramassage des ordures ramasse et jette les objets morts.
En réalité, Java garbage collection fait le contraire! Les objets en direct sont suivis et tout le reste est désigné par garbage.
Lorsqu'un objet n'est plus utilisé, le ramasse-miettes récupère la mémoire sous-jacente et la réutilise pour une allocation ultérieure d'objet. 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 objets ne sont plus utilisés, la machine virtuelle Java exécute par intermittence ce que l’on appelle très justement un algorithme mark-and-sweep.
Vérifiez ceci pour plus d'informations détaillées: http://javabook.compuware.com/content/memory/how-garbage-collection-works.aspx
Le ramasse-miettes permet à votre ordinateur de simuler un ordinateur avec une mémoire infinie. Le reste n'est qu'un mécanisme.
Pour ce faire, il détecte quand des morceaux de mémoire ne sont plus accessibles à partir de votre code et renvoie ces morceaux au magasin gratuit.
EDIT: Oui, le lien est pour C #, mais C # et Java sont identiques à cet égard.
Pour résumer les termes les plus simples que même un non-programmeur puisse comprendre, lorsqu'un programme traite des données, il crée des données intermédiaires et un espace de stockage (variables, tableaux, certaines métadonnées d'objet, etc.) pour ces données.
Lorsque ces objets sont accessibles via des fonctions ou sur une certaine taille, ils sont alloués à partir d'un segment de mémoire central. Ensuite, quand ils ne sont plus nécessaires, ils doivent être nettoyés.
Il existe de très bons articles en ligne sur la façon dont cela fonctionne. Je ne traiterai donc que de la définition de base.
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 objet actif et supprime effectivement les objets, puis copie et compacte la mémoire. C'est un peu plus compliqué que cela, mais vous voyez l'idée.
Le gros problème est que certaines parties de ce processus nécessitent souvent l'intégralité de Java VM obliger à être arrêté temporairement), ainsi que l'intégralité de ce processus Utilisation intensive du processeur et de la bande passante mémoire.
Le ramasse-miettes peut être considéré comme un gestionnaire de comptage de références. si un objet est créé et que sa référence est stockée dans une variable, son nombre de références est augmenté de un. au cours de l'exécution si cette variable est affectée avec NULL. Le nombre de références pour cet objet est décrémenté. le nombre de références actuel de l'objet est donc 0. Désormais, lorsque le récupérateur de place est exécuté, il recherche les objets dont le nombre de références est 0 et libère les ressources qui lui sont allouées.
L'invocation du récupérateur de place est contrôlée par des règles de récupération de place.
Vous pouvez obtenir des données ici. http://www.Oracle.com/technetwork/Java/gc-tuning-5-138395.html
Les principes de base de la récupération de place consistent à rechercher dans un programme des objets de données inaccessibles à l'avenir et à récupérer les ressources utilisées par ces objets. https://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29
Avantages
1) Sauvegarde des bugs, qui surviennent lorsqu'un morceau de mémoire est libéré alors qu'il y a encore des pointeurs sur celui-ci, et qu'un de ces pointeurs est déréférencé. https://en.wikipedia.org/wiki/Dangling_pointer
2) Double bugs libres, qui se produisent lorsque le programme tente de libérer une zone de mémoire déjà libérée et peut-être déjà allouée à nouveau.
3) Empêche certains types de fuites de mémoire, dans lesquelles un programme ne parvient pas à libérer la mémoire occupée par des objets devenus inaccessibles, ce qui peut entraîner un épuisement de la mémoire.
Inconvénients
1) Consommer des ressources supplémentaires, des impacts sur les performances, des blocages possibles dans l'exécution du programme et une incompatibilité avec la gestion manuelle des ressources. La récupération de place consomme des ressources informatiques pour décider de la mémoire à libérer, même si le programmeur a déjà connu ces informations.
2) Le moment où les ordures sont effectivement collectées peut être imprévisible, entraînant des blocages (pauses pour décaler/libérer de la mémoire) dispersés tout au long d'une session. Les décrochages imprévisibles peuvent être inacceptables dans des environnements en temps réel, dans le traitement de transactions ou dans des programmes interactifs.
Tutoriel Oracle http://www.Oracle.com/webfolder/technetwork/tutorials/obe/Java/gc01/index.html
Le ramassage des ordures est le processus qui identifie les objets utilisés et ceux qui ne le sont pas et qui supprime les objets inutilisés.
Dans un langage de programmation tel que C, C++, l'allocation et la libération de mémoire sont des processus manuels.
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-miettes identifie les pièces de mémoire utilisées et celles qui ne le sont pas.
Étape 2a. La suppression normale supprime les objets non référencés, laissant les objets référencés et les pointeurs sur l'espace libre.
Pour améliorer les performances, nous souhaitons supprimer les objets non référencés et également compacter les objets référencés restants. Nous voulons garder les objets référencés ensemble, de sorte qu'il sera plus rapide d'allouer une nouvelle mémoire.
Comme indiqué précédemment, il est inefficace de devoir marquer et compacter tous les objets d'une machine virtuelle. Au fur et à mesure que de plus en plus d'objets sont alloués, la liste d'objets s'allonge, ce qui allonge le temps de récupération des déchets.
Continuez à lire ce didacticiel et vous saurez comment le GC relève ce défi.
En bref, il y a trois régions du tas, YoungGeneration pour les objets à vie courte, OldGeneration pour les objets de longue période et PermanentGeneration pour les objets qui vivent pendant la vie de l'application, par exemple les classes, les bibliothèques.
La récupération de place fait référence au processus de libération automatique de mémoire sur le tas en supprimant les objets qui ne sont plus accessibles dans votre programme. Le segment de mémoire est une mémoire appelée magasin libre. Elle représente un important pool de mémoire inutilisée allouée à votre application Java.
La collecte automatique des ordures consiste à examiner la mémoire de tas, à identifier les objets utilisés et ceux qui ne le sont pas, et à supprimer les objets inutilisés. Un objet en cours d'utilisation, ou un objet référencé, signifie qu'une partie de votre programme conserve toujours un pointeur sur cet objet. Un objet non utilisé ou un objet non référencé n'est plus référencé par aucune partie de votre programme. Ainsi, la mémoire utilisée par un objet non référencé peut être récupérée.
Dans un langage de programmation tel que C, l'allocation et la désallocation de mémoire sont des processus manuels. En Java, le processus de libération de la mémoire est géré automatiquement par le ramasse-miettes. 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 ramasse-miettes est un composant de jvm.
Il est utilisé pour ramasser les ordures chaque fois que le cpu devient gratuit.
Ici, garbage signifie les objets inutilisés qu'il exécute en arrière-plan du programme principal
pour surveiller l'état du programme principal.
Comme les objets sont alloués dynamiquement par l'opérateur new, vous pouvez demander comment ces objets 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 les objets alloués manuellement de manière dynamique par l'opérateur de suppression. Java a une approche différente; il gère automatiquement la désallocation. La technique est connue sous le nom de Garbage Collection.
Cela fonctionne comme ceci: quand il n'y a aucune référence à un objet, on suppose que cet objet n'est plus nécessaire et vous pouvez récupérer la mémoire occupée par l'objet. Il n'est pas nécessaire de détruire explicitement les objets comme en C++. Le ramassage des ordures a lieu sporadiquement pendant l'exécution du programme. Cela n'arrive pas simplement parce qu'il y a un ou plusieurs objets qui ne sont plus utilisés. De plus, plusieurs implémentations de l'exécution Java) ont des approches différentes en matière de récupération de place, mais la plupart des programmeurs n'ont pas à s'en préoccuper lors de l'écriture de programmes.
La récupération de place dans Java (ainsi que dans d'autres langages/plateformes) permet à l'environnement d'exécution JJava de réutiliser la mémoire des objets Java. qui ne sont plus nécessaires. De manière simpliste, lorsque le JRE démarre pour la première fois, il demande au système d’exploitation (O/S) une certaine quantité de mémoire. Lorsque le JRE exécute votre/vos application (s), il utilise cette mémoire. Lorsque votre application utilise cette mémoire, le "Garbage Collector" du JRE arrive et récupère cette mémoire pour qu'elle puisse être utilisée par différentes parties de votre/vos application (s) existante (s). Le "ramasse-miettes" du JRE est une tâche d'arrière-plan qui est toujours en cours d'exécution et qui essaie de choisir les moments où le système est inactif pour exécuter ses cycles de mise au rebut.
Une analogie du monde réel serait celle des éboueurs qui viennent chez vous et ramassent vos ordures recyclables.