GC.Collect() et Finaliser

Ok, il est connu que la GC appelle implicitement Finalize méthodes sur des objets lors de l'identification de l'objet en tant que déchets. Mais qu'advient-il si je fais une GC.Collect()? Sont les finaliseurs encore exécuté? Une question stupide peut-être, mais quelqu'un m'a demandé ce et j'ai répondu un "Oui" et puis j'ai pensé: "a Été entièrement correcte?"

  • Pourquoi vous n'essayez pas de le faire en faisant des journaux dans le destructeur de voir n' "Finaliser" appelé ou pas? ou j'ai raté quelque chose?!
  • Ce n'est certainement pas une "question stupide".
  • Oui j'ai pu le faire, et éviter de poster la question. Mais alors la connaissance serait juste de les confiner à moi. La bonne partie de est - en le postant ici, j'ai eu de plus d'élaborer des réponses sur le sujet, et j'espère que cela aidera d'autres utilisateurs de trop!
  • Voir aussi: Sont .net finaliseurs toujours exécuté?
InformationsquelleAutor Sandeep | 2012-12-19
  1. 75

    Ok, il est connu que la GC appelle implicitement Finaliser méthodes sur des objets lors de l'identification de l'objet en tant que déchets.

    Pas de pas de pas de. Ce n'est pas connu parce que, pour être connaissances une déclaration doit être vrai. Cette déclaration est faux. Le garbage collector ne pas exécuter les finaliseurs retraçant, qu'il exécute lui-même ou si vous appelez Collect. Le finaliseur thread exécute les finaliseurs après le tracé du collecteur a trouvé la poubelle et ce qui se passe de manière asynchrone à l'égard d'un appel à Collect. (Si ça arrive, qu'il ne pourrait pas, comme une autre réponse souligne.) Qui est, vous ne pouvez pas compter sur le finaliseur thread d'exécution avant le retour du contrôle de Collect.

    Voici une esquisse schématique de la façon dont il fonctionne:

    • Lorsqu'une collection qui se passe le garbage collector retraçant fil retrace les racines -- les objets connus pour être vivant, et chaque objet ils se réfèrent, et ainsi de suite-à déterminer les objets morts.
    • "Mort" des objets qui sont en attente, finaliseurs sont déplacées sur le finaliseur file d'attente. Le finaliseur file d'attente est une racine. Par conséquent, ces "morts", les objets sont en fait des encore en vie.
    • Le finaliseur le fil, qui est généralement un autre thread que le GC traçage du fil, par la suite et vide le finaliseur file d'attente. Ces objets deviennent alors réellement mort, et sont recueillies dans le prochaine collection sur le traçage fil. (Bien sûr, puisqu'ils ont juste survécu à la première collection, ils pourraient être plus dans une génération.)

    Comme je l'ai dit, c'est simplifiée à l'extrême; les détails de la façon dont le finaliseur file d'attente de travaux sont un peu plus compliquées que cela. Mais il devient assez de l'idée à travers. La conséquence pratique est ici que vous ne pouvez pas supposer que l'appel Collect gère également les finaliseurs, car il n'a pas. Permettez-moi de le répéter, une fois de plus: le tracé partie du garbage collector ne pas exécuter les finaliseurs, et Collect ne fonctionne que le traçage partie du mécanisme de collecte.

    Appel de la bien nommée WaitForPendingFinalizers après l'appel de Collect si vous voulez vous assurer que tous les finaliseurs ont couru. Qui va interrompre le thread courant jusqu'à ce que le thread finaliseur se déplace à vider la file d'attente. Et si vous voulez vous assurer que ceux finalisé les objets ont leur mémoire récupérée, alors vous allez avoir à appeler Collect un deuxième temps.

    Et bien sûr, il va sans dire que vous ne devriez faire cela pour le débogage et le test. Ne jamais faire de ce non-sens dans le code de production sans vraiment, vraiment une bonne raison.

    • Je aveuglément cru msdn.microsoft.com/en-us/magazine/bb985010.aspx. La "Finalisation" de la section dans l'article mentionne que "le garbage collector appelle l'objet de la méthode Finalize".... Ne peux pas croire que ces fausses déclarations sont enregistrées dans la msdn magazine!
    • Eh bien, je suppose que cela dépend si vous considérez le finaliseur thread pour faire partie du garbage collector ou pas. Je pense que le garbage collector comme spécifiquement la chose qui retrace les racines, mais si vous pensez que le garbage collector comme tous les mécanismes qui traitent de nettoyage puis je pense que c'est vrai. Je vais préciser la réponse.
    • Alors, quel est-il réellement? Comme vous l'avez dit, GC est une "racine traceur" ou est-il un "nettoyage complet de la machine"? Je ne veux pas penser/supposons que. Je suis à la recherche de la vérité!
    • La vérité importante à la recherche de pour n'est pas ce que nous entendons par "le garbage collector", mais plutôt, la réponse à votre question de départ: comment pouvons-nous garantir que les finaliseurs ont été exécutés? Vous garantie que par l'attente du thread finaliseur de faire son travail.
    • Je suis entièrement d'accord pour que. Mais je voulais juste savoir (mauvaise curiosité)- Qui informe le finaliseur thread pour lancer l'exécution? Est-ce la CG?
    • I pense, mais je n'en suis pas sûr; je n'ai jamais travaillé sur la table elle-même. Cette question est peut-être d'intérêt pour vous: stackoverflow.com/questions/5223325/...
    • Sympa de vous voir de retour sur soi, Eric.
    • Merci! Il est agréable d'avoir un peu de temps libre à y consacrer! Nous allons voir combien de temps elle dure.
    • N'est-il pas correct de dire que les objets de l'outil de finalisation de la file d'attente toujours à la fin en plus de la génération d'avant, ils sont effectivement collectés?
    • Pas de. Les objets qui entrent dans la file d'attente de finalisation après avoir été dans le tas d'objets volumineux ne pas aller à une hausse de la génération, parce que la liturgie des heures n'est pas générationnel. Les objets qui entrent dans la file d'attente de finalisation à la fin de l'2-génération de ne pas aller à une hausse de la génération parce que 2 est le plus élevé. Les objets qui entrent dans la file d'attente de finalisation sur la non-générationnelle versions de la CLR, comme le compact framework, n'allez pas plus d'une génération.
    • Vous avez raison bien sûr, je pensais à la "normale" tas seulement. Où la finalisation des objets aura au moins laissé la génération 0.

    InformationsquelleAutor Eric Lippert
  2. 15

    En réalité la réponse: "Ça dépend". En fait il y a un thread qui exécute tous les finaliseurs. Cela signifie que l'appel à GC.Collect seulement déclenché ce processus et l'exécution de toutes les finaliseurs serait appelée de façon asynchrone.

    Si vous voulez attendre jusqu'à ce que tous les finaliseurs serait appelé vous pouvez utiliser l'astuce suivante:

    GC.Collect();
//Waiting till finilizer thread will call all finalizers
GC.WaitForPendingFinalizers();
    • Il y a des raisons pour lesquelles vous pourriez vouloir faire cela (par exemple, comme une optimisation des performances). Toutefois, si la motivation pour l'utilisation de ce code est de fixer la logique du programme, le code doit probablement être à l'aide de IDisposable.Dispose (idéalement par une instruction d'utilisation) à la place.
    InformationsquelleAutor Sergey Teplyakov
  3. 10

    Oui, mais pas tout de suite. Cet extrait est tiré de La Collecte des ordures: Gestion Automatique de la Mémoire dans le Microsoft .NET Framework (MSDN Magazine) (*)

    "Lorsqu'une application crée un nouvel objet, l'opérateur new alloue
    la mémoire dans le tas. Si le type de l'objet contient un Finaliser
    méthode, puis un pointeur vers l'objet est placé sur la finalisation
    la file d'attente. La file d'attente de finalisation est une structure de données interne contrôlé
    par le garbage collector. Chaque entrée dans la file d'attente des points d'un objet
    qui doit avoir sa méthode Finalize appelé avant que l'objet du mémoire
    peut être récupérée.

    Lorsqu'un GC se produit ... le garbage collector analyses de la finalisation
    la file d'attente à la recherche pour les pointeurs vers ces objets. Lorsqu'un pointeur est trouvé,
    le pointeur est supprimé de la file d'attente de finalisation et annexé à la
    file d'attente freachable (prononcé "F-accessible"). La file d'attente freachable est
    une autre structure de données interne contrôlé par le garbage collector.
    Chaque pointeur dans la file d'attente freachable identifie un objet qui est
    prêt à avoir sa méthode Finalize appelé.

    Il existe un thread d'exécution dédiée à l'appel à Finaliser
    des méthodes. Lorsque la file d'attente freachable est vide (ce qui est généralement le
    cas), ce thread est en veille. Mais lorsque les entrées apparaissent, ce fil se réveille,
    supprime chaque entrée de la file d'attente, et des appels de chaque objet Finaliser
    la méthode. De ce fait, vous ne devriez pas exécuter le code dans un de Finaliser
    méthode qui a fait aucune hypothèse sur le thread d'exécution de la
    code. Par exemple, évitez le thread d'accès local de stockage dans le
    Méthode Finalize."

    (*) À partir de novembre 2000, donc les choses ont peut être changé depuis.

    InformationsquelleAutor stuartd
  4. 5

    Lorsque les ordures sont collectées (que ce soit en réponse à la sollicitation de la mémoire ou GC.Collect()), les objets nécessitant une finalisation sont mis à la file d'attente de finalisation.

    Sauf si vous appelez GC.WaitForPendingFinalizers(), les finaliseurs peut continuer à s'exécuter dans le contexte de temps après la collecte des ordures a fini.

    BTW, il n'y a aucune garantie finaliseurs sera appelé à tous les. De MSDN...

    La méthode Finalize peut ne pas s'exécuter jusqu'à la fin ou peut ne pas fonctionner à
    tous les dans les situations exceptionnelles suivantes:

    • Un autre finaliseur bloque indéfiniment (entre dans une boucle infinie, essaie d'obtenir une serrure, il ne peut jamais obtenir et ainsi de suite). Parce que le
      runtime tente d'exécuter les finaliseurs à la fin, d'autres les finaliseurs
      pourrait ne pas être appelé si un finaliseur bloque indéfiniment.
    • Le processus se termine sans donner le runtime une chance de nettoyer. Dans ce cas, l'exécution de la première notification de processus
      la résiliation est un DLL_PROCESS_DETACH notification.

    L'exécution continue à Finaliser les objets lors de l'arrêt seulement, tandis que
    le nombre d'objets finalisables continue de diminuer.

    InformationsquelleAutor Branko Dimitrijevic
  5. 0

    Couple de plus de points valent la peine d'état ici.

    Finalizer est le dernier point où .net les objets peuvent libérer des ressources non managées.
    Les finaliseurs doivent être exécutées uniquement si vous ne jetez pas votre cas correctement. Idéalement, les finaliseurs doit jamais être exécutée dans de nombreux cas. Parce que les règles de disposer de la mise en œuvre devrait supprimer la finalisation.

    Voici un exemple pour corriger IDispoable mise en Œuvre.

    Si vous appelez la méthode dispose de tout jetable objets, il est conseillé de désactiver toutes les références et la Suppression de la finalisation. Si il n'est pas si bon développeur qui a oublier d'appeler la méthode dispose, Finalizer est la vie de veille.

    InformationsquelleAutor CharithJ