Qu'est-ce que le garbage collector en Java?

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 c'est extrêmement artificiel, mais ici, après avoir appelé otherMethod(), l'original Object créé est rendu inaccessible - et c'est "garbage" qui récupère les ordures.

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

Pour en savoir plus, voir l'article de wikipédia sur collecte des Ordures et Réglage de Collecte des Ordures (Oracle)

Un objet devient éligible pour Garbage collection ou GC s'il n'est pas accessible à partir de threads en direct ou par des références statiques.

En d'autres termes, vous pouvez dire qu'un objet devient éligible à la récupération de place si toutes ses références sont null. Les dépendances cycliques ne sont pas comptées comme référence donc 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 aucune autre référence en direct alors les objets A et B seront éligibles pour La collecte des ordures.

Génération de tas pour la collecte des ordures -

Les objets Java sont créés dans Heap et {[2] } est divisé en trois parties ou générations pour des raisons de garbage collection en Java, ceux-ci sont appelés comme Jeune (Nouvelle) génération, Génération titulaire (Ancienne) et Zone de Perm du tas.

New Generation est en outre divisé en trois parties connues sous le nom d'Eden space, Survivor 1 et Survivor 2 espace. Lorsqu'un objet créé pour la première fois dans le tas, il est créé dans une nouvelle génération à l'intérieur de l'espace Eden et après une ramasse-miettes mineure ultérieure si un objet survit, il est déplacé vers survivor 1, puis survivor 2 avant que la ramasse-miettes majeure ne déplace cet objet vers ancienne génération.

L'espace Perm du tas Java est l'endroit où la JVM stocke les métadonnées sur les classes et les méthodes, le pool de chaînes et les détails au niveau des classes.

Se référer ici pour plus d' : Collecte des Ordures

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

En java.lang.Système

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

En java.lang.Runtime

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. Un, il devrait être en mesure pour détecter tous les objets inaccessibles et deuxièmement, il doit récupérer l'espace de tas utilisé par les objets garbage et rendre l'espace à nouveau disponible pour le programme.

Les opérations ci-dessus sont effectuées par l'algorithme Mark and Sweep en deux phases:

1. Marquer la phase
2. Phase de balayage

Lire ici pour plus de détails - Marque et de Balayage de l'Algorithme

Garbage collector implique que les objets qui ne sont plus nécessaires au programme sont des "ordures" et peuvent être jetés.

Garbage Collector fait partie de JRE qui s'assure 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. AFAIK il détient un graphique qui représente les liens entre les objets et les objets isolés peuvent être libérés.
Pour économiser les performances des objets actuels regroupés en générations, chaque fois que GC scanne un objet et constate qu'il est toujours référencé son nombre de génération incrémenté de 1 (à une valeur maximale maximale, 3 ou 4 je pense) , et la nouvelle génération sont scannés en premier (plus l'objet en mémoire est court, plus il n'est probablement plus nécessaire), donc tous les objets ne sont pas scannés à chaque fois que GC s'exécute.
lire ce pour plus d'informations.

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

Il le fait en détectant quand des morceaux de mémoire ne sont plus accessibles à partir de votre code et en renvoyant ces morceaux au magasin gratuit.

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

Beaucoup de gens pensent que garbage collection collecte et rejette les objets morts.
En réalité, Java garbage collection fait le contraire! Les objets en direct sont suivis et tout le reste désigné ordures.

Lorsqu'un objet n'est plus utilisé, le garbage collector récupère la mémoire sous-jacente et la réutilise pour une allocation d'objet future. 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, le JVM exécute par intermittence ce qu'on appelle très bien un algorithme de mark-and-sweep.

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

Garbage Collection en Java (et dans d'autres langages/plates-formes également) est un moyen pour l'environnement d'exécution java (JRE) de réutiliser la mémoire des objets java qui ne sont plus nécessaires. 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 le JRE exécute vos applications, 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 une utilisation par différents parties de vos applications existantes. Le "Garbage Collector" du JRE est une tâche d'arrière-plan qui est toujours en cours d'exécution et essaie de choisir les moments où le système est inactif pour continuer ses exécutions de déchets.

Une analogie du monde réel serait les éboueurs qui viennent chez vous et ramassent vos déchets recyclables... finalement, son réutilisé dans d'autres façons, par vous-même et/ou d'autres personnes.

Garbage collector peut être considéré comme un gestionnaire de comptage de référence. 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é d'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é. ainsi, le nombre de références actuel pour l'objet est 0. Maintenant, lorsque Garbage collector est exécuté, Il vérifie les objets avec le nombre de référence 0. et libère les ressources allouées à il.

L'invocation du Garbage collector est contrôlée par les stratégies de Garbage collection.

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

Garbage collector est un composant de jvm.

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

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.

La récupération de place automatique est le processus consistant à examiner la mémoire de tas, à identifier les objets utilisés et ceux qui ne le sont pas et à supprimer les objets inutilisés. Une utilisation objet, ou un objet référencé, signifie qu'une certaine partie de votre programme conserve un pointeur vers cet objet. Un objet inutilisé, 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 comme C, l'allocation et la désallocation de la mémoire sont un processus manuel. En Java, le processus de désallocation de la mémoire est géré automatiquement par le garbage collector. Veuillez vérifier le lien pour une meilleure compréhension. http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html

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

Les principes de base de garbage collection sont de trouver des objets de données dans un programme qui ne peut pas être consulté à l'avenir, et de récupérer les ressources utilisées par ces objets. https://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29

Avantages

1) Enregistre des bogues, qui se produisent lorsqu'un morceau de mémoire est libéré alors qu'il y a 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à 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) consommation de ressources supplémentaires, impacts sur les performances, décrochages possibles dans l'exécution du programme et incompatibilité avec la gestion manuelle des ressources. Garbage collection consomme des ressources informatiques pour décider quelle mémoire libérer, même si le programmeur a peut-être déjà connu cette information.

2) Le moment où les déchets sont réellement collectés peut être imprévisible, ce qui entraîne des blocages (pauses pour déplacer/libérer la mémoire) dispersés tout au long d'une session. Des décrochages imprévisibles peuvent être inacceptables dans des 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

Garbage collection est le processus identifiant quels objets sont utilisés et lesquels ne le sont pas, et supprimant les objets inutilisés.

Dans un langage de programmation comme 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 est appelée marquage. C'est là que le garbage collector identifie les morceaux de mémoire utilisés et ceux qui ne le sont pas.

Étape 2a. La suppression normale supprime les objets non référencés en laissant des objets référencés et des pointeurs sur de l'espace libre.

Pour améliorer les performances, nous voulons supprimer les objets non référencés et compacter les objets référencés restants. Nous voulons garder les objets référencés ensemble, il sera donc plus rapide d'allouer une nouvelle mémoire.

Comme indiqué précédemment, avoir à marquer et compacter tous les objets dans une JVM est inefficace. À mesure que de plus en plus d'objets sont alloués, la liste des objets s'allonge et s'allonge, ce qui entraîne un temps de récupération de place de plus en plus long.

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

Bref, il y a trois régions du tas, YoungGeneration pour la courte vie des objets, OldGeneration pour une longue période objets, et PermanentGeneration pour les objets qui vivent pendant la vie de l'application, par exemple, les classes, les bibliothèques.

Comme les objets sont alloués dynamiquement par l'opérateurnew , 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 dynamiquement les objets alloués manuellement par l'opérateur delete. Java a une approche différente; 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 pas de références à un objet, on suppose que cet objet n'est pas 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 des objets comme en C ++. La récupération de place se produit sporadiquement pendant l'exécution du programme; Cela ne se produit pas simplement parce qu'il y a un ou plusieurs objets qui ne sont plus utilisés. De plus, plusieurs implémentations Java runtime ont des approches différentes de la récupération de place, mais la plupart des programmeurs n'ont pas à se soucier d'écrire des programmes

Un objet devient éligible pour Garbage collection ou GC s'il n'est pas accessible à partir de threads en direct ou par des références statiques.

En d'autres termes, vous pouvez dire qu'un objet devient éligible à la récupération de place si toutes ses références sont null. Les dépendances cycliques ne sont pas comptées comme référence donc 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 aucune autre référence en direct alors les objets A et B seront éligibles pour La collecte des ordures.

Génération de tas pour la collecte des ordures-

Les objets Java sont créés dans Heap et Heap est divisé en trois parties ou générations pour des raisons de garbage collection en Java, ceux-ci sont appelés comme Jeune (Nouvelle) génération, Génération titulaire (Ancienne) et Zone de Perm du tas.

La nouvelle génération est divisée en trois parties connues sous le nom d'Eden space, Survivor 1 et Survivor 2 space. Lorsque un objet créé pour la première fois dans le tas est créé dans une nouvelle génération dans l'espace Eden et après une ramasse-miettes mineure ultérieure si un objet survit, il est déplacé vers survivor 1, puis survivor 2 avant que la ramasse-miettes majeure ne déplace cet objet vers génération ancienne ou permanente.

L'espace Perm du tas Java est l'endroit où la JVM stocke les métadonnées sur les classes et les méthodes, le pool de chaînes et les détails au niveau des classes.

Pour le dire dans les termes les plus 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'objet, etc.) pour que les données.

Lorsque ces objets sont accessibles à travers des fonctions ou sur une certaine taille, ils sont alloués à partir d'un tas central. Ensuite, quand ils ne sont pas longtemps nécessaires, ils doivent être nettoyés.

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

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, supprimant efficacement les objets, que copie et compacte la mémoire. C'est un peu plus compliqué que ça, mais vous avez l'idée.

Le gros problème est que certaines parties de ce processus nécessitent souvent que l'ensemble de la machine virtuelle Java soit arrêté temporairement pour avoir lieu, ainsi que l'ensemble processus étant très processeur et la bande passante de la mémoire intensive. Les différentes options de GCs et les options de réglage pour chacun sont conçues pour équilibrer ces divers problèmes avec l'ensemble du processus GC.

La récupération de place automatique est un processus dans lequel la JVM se débarrasse ou conserve certains points de données en mémoire pour finalement libérer de l'espace pour le programme en cours d'exécution. La mémoire est d'abord envoyée à la mémoire de tas, c'est-à-dire où le garbage collector (GC) fait son travail, puis est décidée à être terminée ou conservée. Java suppose que le programmeur ne peut pas toujours être fiable, il termine donc les éléments dont il pense qu'il n'a pas besoin.