Quelles sont les causes?

Quelles sont les racines de la collecte des ordures?

J'ai lu la définition de la racine que "toute référence que vous programme peut accéder à" et la définition de live, c'est qu'un objet qui est utilisé, qui peut être une variable locale, variable statique.

Je m peu confus avec discriminatoire de la différence entre la racine et les objets vivants.

Qu'est-ce que le chemin à la racine? Comment racine et de vivre les objets de travail?

Quelqu'un peut-il développer ?

Ce minable définitions 🙂 je voudrais commencer à Garbage Collection
où avez-vous lu ces définitions?
cs.berkeley.edu/~jrs/61b/lec/40.pdf
la définition de cette page pour la racine est: "toute référence à l'objet de votre programme peut accéder directement, sans passer par un autre objet". C'est très différent de "toute référence que vous programme peut accéder à". C'est très spécifique dans votre programme contient les références au dit objet géré, et que votre programme n'a pas besoin de traverser le tas pour arriver à la racine.
vous aurez besoin de visualiser la JVM/CLR que le processus qui permettent de gérer le tas. Les seuls objets dans le tas, que le processus en est conscient, est l'ensemble de la pile de thread cadres en cours d'exécution, les classes qui ont été chargés, parmi quelques autres. C'est la racine de la rp, et tous les autres objets dans le tas est soit accessible ou inaccessible à partir de ce jeu.

InformationsquelleAutor DarthVader | 2011-06-16

85

Si vous pensez que les objets dans la mémoire comme un arbre, les "racines" est la racine de nœuds - chaque objet immédiatement accessible par votre programme.
```
Person p = new Person();
p.car = new Car(RED);
p.car.engine = new Engine();
p.car.horn = new AnnoyingHorn();
```
Il y a quatre objets; une personne, une voiture rouge, son moteur et klaxon. Tracer le graphique de référence:
```
     Person [p]
        |
     Car (red)
   /           \
Engine    AnnoyingHorn
```
Et vous vous retrouverez avec Person à la "racine" de l'arbre. Il est vivant parce qu'il est référencé par une variable locale, p, dont le programme pourrait utiliser à tout moment pour consulter le Person objet. Cela vaut également pour les autres objets, à travers p.car, p.car.engine, etc.

Depuis Person et tous les autres objets de manière récursive qui y sont connectés sont en direct, il y aurait des problèmes si le GC a recueillis.

Considérer, cependant, si le suivant est exécuté après un certain temps:
```
p.car = new Car(BLUE);
```
Et de redessiner le graphique:
```
     Person [p]
        |
     Car (blue)       Car (red)
                    /           \
                Engine    AnnoyingHorn
```
Maintenant la Person est accessible par le biais de p et la voiture bleue à travers p.car, mais il n'existe aucun moyen de la voiture rouge ou de ses parties, ne peut jamais être de nouveau accessible - ils ne sont pas connectés à un live de la racine. Ils peuvent être en toute sécurité collectées.

Donc, c'est vraiment une question de prendre chaque point de départ (toutes les variables locales, variables globales, statique, tout dans d'autres threads et la pile d'images) — chaque racine et, récursivement, à la suite de toutes les références pour établir une liste de tous les objets "en direct": les objets qui sont en cours d'utilisation et ne convient pas pour la suppression. Tout le reste est des ordures, en attente d'être collectés.
- Cette réponse est incorrecte. GC Racines sont ces classes chargées par la JVM par [Veneet de réponse], plus spécifiquement, les Threads, les classes chargées par le système de chargeur de classe, les références de la pile, JNI et les objets en attente de finalisation.
- Voir cette autre réponse pour une liste de causes possibles. Dans cette réponse, Person n'est pas une racine, il est accessible par un (et probablement plus d'un) de la racine.
- Comme la question ne précise pas de Java ou JVM n'importe où (à part les balises qui contiennent également .NET et CLR si vous regardez assez proche) et semble être plutôt générique, ainsi que ma réponse. Merci pour la clarification de la Java, mais je ne vois pas comment il annule ma réponse générique.
- Dans votre exemple précis, dans toute gestion de l'environnement, Person est pas un GC de la racine; la racine GC est le chose, qui détient la référence à Person. La différence est subtile, mais importante dans le contexte de cette question. Bien que ma réponse est spécifique à Java, il est en général correcte pour n'importe quel langage managé. Votre dernier paragraphe est vraiment bon, mais les conflits avec l'exemple donné.
- Je vois.
- J'aime toujours cette réponse car elle permet de clarifier comment GC fonctionne "en général".
InformationsquelleAutor aib
35

Le GC (Garbage Collector) les racines sont des objets spéciaux pour le garbage collector. Le Garbage Collector recueille les objets qui ne sont pas GC racines et ne sont pas accessibles par les références de GC racines.

Il y a plusieurs sortes de GC racines. Un objet peut appartenir à plus d'un type de racine. La racine types sont:
- Classe - classe chargée par le système de chargeur de classe. De telles classes ne peut jamais être déchargé. Ils peuvent contenir des objets via des champs statiques. Veuillez noter que les classes chargées par classe personnalisée, les chargeurs ne sont pas des racines, correspondant à moins que les instances de java.lang.Class arriver à être les racines de l'autre type(s).
- Fil - fil en direct
- Pile Local - Local variable ou d'un paramètre de méthode Java
- JNI Locale locale de la variable ou d'un paramètre de la JNI méthode
- JNI Mondiale - JNI mondiale de référence
- De l'écran Utilisé - objets à utiliser comme un moniteur pour la synchronisation
- Détenus par la JVM - objets détenus de la collecte des ordures par la JVM pour ses fins. En fait la liste de ces objets dépend de la JVM. Possible cas les plus connus sont: le système de chargeur de classe, quelques classes d'exception que la JVM sait à ce sujet, quelques pré-objets alloués pour la gestion des exceptions, et la classe personnalisée chargeurs quand ils sont dans le processus de chargement des classes. Malheureusement, JVM fournit absolument aucun détail supplémentaire pour de tels objets. Ainsi, il appartient à l'analyste de décider auquel cas une certaine "Tenue par la JVM" appartient.
(crédit à YourKit du site web)

Pas mentionné par YourKit est le fait que les objets en attente de finalisation, seront retenus que les racines jusqu'à ce que le GC s'exécute le finalize() méthode. Qui peut provoquer des transitoires de la conservation des grands graphes de façon un peu inattendue. La règle générale est de ne pas utiliser les finaliseurs (mais c'est une autre question).
- Vous pourriez envisager de sourcing cette copie/collé de réponse: yourkit.com/docs/12/help/gc_roots.jsp, ou sinon yourkit pourrait envisager de sourcing, vous :-).
- Ne sont pas mentionnés sont des objets en attente de finalisation, pour que la JVM est titulaire d'une référence jusqu'à la finalisation de l'exécution.
- Parfois, les références sont stockées dans le opérande stack avant ils sont stockés dans les variables locales de la table. Comment le GC résoudre ce problème?
InformationsquelleAutor
29

De racines ou de la collecte des ordures racines sont les objets qui sont toujours joignable. Si un objet est toujours accessible, alors il n'est pas admissible pour la collecte des ordures, les racines sont donc toujours inéligible pour la collection. C'est la première série d'objets à partir d'où l'accessibilité de tous les autres objets sur le tas sont déterminés.

D'autres objets sur le tas accessible à partir de la collecte des ordures racines sont considérées comme des vivre objets, et non admissibles pour la collecte; les objets qui sont inaccessibles peuvent être marqués pour la remise en état.

Je sais Java de plus que le .Net plate-forme, je vais donc parler que pour une seule. Sur la plate-forme Java, le GC racines sont en fait dépendant de l'implémentation. Dans la plupart des runtime cependant, le GC racines ont tendance à être les opérandes sur la pile (car ils sont actuellement en cours d'utilisation par les threads) et de classe (statique) des membres de classes. L'accessibilité est calculé à partir de ces objets dans la plupart des machines virtuelles. Il y a d'autres cas où les paramètres et les opérandes utilisés par JNI les appels seront considérés comme faisant partie de la racine du jeu, et également utilisé pour calculer l'accessibilité.

J'espère que cela efface les doutes persistants sur ce qu'est une racine (set) et qu'est ce qu'un objet en direct.
- je peux dire que les racines sont des pointeurs vers des objets vivants? si il n'y a pas de chemin d'accès à partir d'une racine d'un objet que l'objet peut être revendiquée par la collecte des ordures?
- De la racine sont les objets vivants. N'apportez pas de pointeurs en ce et confondez-vous (GC algorithmes utilisent le nombre de références à un objet pour en déterminer l'accessibilité; voir ce que vous avez fait en considérant les racines comme les pointeurs). Pointeurs/Références doivent être utilisés pour déterminer l'accessibilité.
- Le commentaire ci-dessus aurait dû se lire comme "des Racines sont des objets vivants connus à la JVM/CLR". Le problème avec les traitant comme des pointeurs, c'est que le GC algorithme plus complexe, pour toute GC algorithme traite avec le nombre de pointeurs/références à des objets de distinguer entre les vivants et les objets à collectionner. Une fois qu'une racine est un pointeur, une racine de tous les pointeurs (sic) doivent être traitées différemment, sans bénéfice évident.
- GC racines ont tendance à être les opérandes sur la pile (car ils sont actuellement en cours d'utilisation par les threads)" Qu'entendez-vous par "les opérandes sur la pile"?
- les variables locales à une méthode, c'est des arguments etc.
InformationsquelleAutor Vineet Reynolds
14

La Site web d'IBM énumère les GC racines.

Noter que certains de ces artificiels sont des constructions faites par un mémoire de l'analyseur, mais toujours important d'être conscient de si vous êtes à la recherche à un tas de vidage.
- Système de classe
  
  Une classe qui a été chargé par le chargeur de démarrage, ou le système de chargeur de classe. Par exemple, cette catégorie comprend toutes les classes de la rt.jar fichier (une partie de l'environnement d'exécution Java), tels que ceux dans le java.util.* package.
- JNI locale
  
  Une variable locale dans le code natif, par exemple défini par l'utilisateur JNI code ou de la JVM code interne.
- JNI mondiale
  
  Une variable globale en code natif, par exemple défini par l'utilisateur JNI code ou de la JVM code interne.
- Thread bloc
  
  Un objet qui a été référencé à partir d'un thread actif en bloc.
- Fil
  
  Un thread en cours d'exécution.
- Occupé à surveiller
  
  Tout ce que appelé le wait() ou notify() les méthodes, ou qui est synchronisé, par exemple en appelant la synchronized(Objet) de la méthode ou par l'entrée d'une méthode synchronisée. Si la méthode est statique, la racine est la classe, sinon c'est un objet.
- Java local
  
  Une variable locale. Par exemple, les paramètres d'entrée, ou créés localement des objets de méthodes qui sont encore dans la pile d'un thread.
  Natif de la pile
  
  D'entrée ou de sortie des paramètres dans le code natif, par exemple défini par l'utilisateur JNI code ou de la JVM code interne. De nombreuses méthodes ont natif de pièces, et les objets qui sont traités comme des paramètres de la méthode de devenir la collecte des ordures racines. Par exemple, les paramètres utilisés pour le fichier, réseau, I/O, de réflexion ou des opérations.
- Finaliseur
  
  Un objet qui est dans une file d'attente, en attente d'un finaliseur à exécuter.
- Non
  
  Un objet qui a une méthode finalize, mais n'a pas été finalisé, et n'est pas encore sur le finaliseur file d'attente.
- Inaccessible
  
  Un objet qui est inaccessible à partir de toute autre racine, mais a été marqué comme une racine par la Mémoire de l'Analyseur de sorte que l'objet peut être inclus dans une analyse.
  
  Inaccessible objets sont souvent le résultat d'optimisations dans la collecte des ordures algorithme. Par exemple, un objet peut être un candidat pour la collecte des ordures, mais si petit que le processus de nettoyage serait trop coûteux. Dans ce cas, l'objet peut ne pas être nettoyée, et pourrait rester comme un objet inaccessible.
  
  Par défaut, inaccessible objets en sont exclus lorsque la Mémoire de l'Analyseur analyse le tas de vidage. Ces objets ne sont donc pas indiqué dans l'histogramme, dominateur de l'arbre, ou les résultats de la requête. Vous pouvez modifier ce comportement en cliquant sur le Fichier > Preferences > IBM des Outils de Diagnostic pour Java - Mémoire de l'Analyseur, puis en sélectionnant le Garder inaccessible case à cocher objets.
- Java frame de pile
  
  Java cadre de pile, qui contient les variables locales. Ce type de collecte des ordures de la racine est généré uniquement si vous définissez les Préférences pour traiter Java pile d'images comme des objets. Pour plus d'informations, voir Java de base: les Threads et la pile de thread requêtes.
- Inconnu
  
  Un objet inconnu type de racine. Certaines décharges, tels que Portable IBM Heap Dump (.doctorat), les fichiers n'ont pas racine de l'information. Dans ce cas, la Mémoire de l'Analyseur de parser les marques des objets qui n'ont pas d'inbound références, ou sont inaccessibles à partir de toute autre racine, comme inconnu. Cette action assure que la Mémoire de l'Analyseur de conserve tous les objets dans l'image.
- IBM est toujours dans les parages?
InformationsquelleAutor Lawrence Dol
3

En java, je dirais que les threads sont la racine des objets. Chaque objet live peut être retracée à une discussion en direct. Par exemple, un objet statique est référencé par une classe, qui est référencé par un chargeur de classe, qui est référencée par une autre classe, qui est référencé par une instance de cette classe, ... qui est référencé par un Exécutable, qui est référencé par un fil en direct. (Remarque, les classes peuvent être GC ed, ils ne peuvent pas être des racines)

On peut aussi considérer un "réel" de la racine de tous les threads, mais qui est hors de la sphère de Java standard. Nous ne pouvons pas dire ce que c'est, et comment il les références de tous les threads.
- Les classes chargées, sont aussi des racines (car ils peuvent contenir des variables statique/globale).
- non, ils peuvent être GC ed.
- Les Classes peuvent être GC avais seulement si leur classe chargée devient inaccessible; les classes chargées par le chargeur du système ne peut pas être GC avais.
InformationsquelleAutor irreputable

Vous devez vous connecter pour publier un commentaire.