Pourquoi est-finaliser pas appelée?

J'ai quelques questions concernant le garbage collector de java.

T1.Comme je le comprends, finalize() est appelée lorsque l'objet est en dehors de la portée et de la JVM est sur le point de ramasser les ordures. J'ai pensé méthode finalize() est appelée automatiquement par le garbage collector, mais il ne paraît pas fonctionner dans ce cas. Quelle est l'explication? Pourquoi le besoin de m'appeler explicitement méthode finalize ()?

public class MultipleConstruct {
    int x,y;    
    public MultipleConstruct(int x)
    {
        this.x= x;
        y=5;        
        System.out.println("ONE");
    }

    @Override
    protected void finalize() throws Throwable {
        //TODO Auto-generated method stub
        super.finalize();
        System.out.println("FINALIZED");
    }
    public static void main(String[] args) throws Throwable {
        MultipleConstruct construct = new MultipleConstruct(3);
    }
}

T2. Aussi, lorsque le garbage collector invoquée? Je comprends gc est un fil de démon et invoqué par la JVM en fonction de la taille du segment restant. Est-ce à dire, JVM attend pour le programme à utiliser seuil de ressources et d'en notifier le gc pour balayer les ordures des objets.

EDIT: Comment gc résolu références circulaires?

GC est effectué chaque fois que la JVM pense qu'il doit l'appeler, bien que l'IIRC l'Oracle de la JVM sera fait appel par un Système.gc (). Autant que je me souvienne c'est aussi de ne pas être appelé. Pour votre exemple, comment faites-vous tester pour voir si/quand on l'appelle?
N'utilisez pas finalize (), il n'est en aucune façon l'équivalent d'un destructeur C++.
je suis d'accord, mais alors ce que pourrait être une façon de mettre en œuvre destructeur comme le comportement en java je.e sans bug ressources de nettoyage.
Utiliser try {} finally {} blocs de bug ressource gratuite de nettoyage.
ce n'est pas la solution dans des cas tels que u ont de la peinture de la méthode dans un objet qui a attiré l'image sur l'écran, et maintenant il est hors de portée, mais l'image est toujours visible sur l'écran. U besoin d'un destructeur qui va permettre de nettoyer l'image sur l'écran. n'est-ce pas?

OriginalL'auteur prap19 | 2011-10-16

garbage-collection java

8

Il y a beaucoup de méthode finalize() qui est franchement beaucoup de choses à écrire, mais en bref:

D'un objet dans la version finale de l'état, si elle est toujours inaccessible après sa méthode finalize, le cas échéant, a été exécuté. La version définitive de l'objet est en attente de libération de la mémoire. Notez que la machine virtuelle de mise en œuvre de contrôles lors de la finalizer est exécuté. Vous êtes presque toujours mieux de faire votre propre nettoyage au lieu de s'appuyer sur un outil de finalisation. À l'aide d'un finaliseur peut laisser derrière lui les ressources qui ne seront pas repris pour un montant indéterminé de temps.

Dans votre cas, la raison pour laquelle il n'a pas l'impression, c'est que vous ne savez pas quand le finaliseur thread va appeler la méthode finalize (). Ce qui se passe est que le programme est appelé à disparaître avant que quelque chose peut être imprimé. Pour le vérifier:
modifiez le code dans le code principal par( NOTE: ce n'est pas garantie, ni si vous devez jamais compter sur elle, mais encore il fait des tirages un peu de temps)
```
for(int i =0;i<1000000;i++)
    {
        MultipleConstruct construct = new MultipleConstruct(3);
        construct = null;
    }
```
Il y a beaucoup d'inconvénients de l'utilisation d'un finalize() droit de prendre plus de temps dans la construction de l'objet à la possibilité de fuites de mémoire et de la mémoire de la famine. Si vous fortement de se référer au même objet à l'intérieur de la finalize() alors il n'est jamais appelé la deuxième fois et peut donc sortir du système en non désirée, etc etc etc...
Le seul endroit où vous devez utiliser finalize() est comme un filet de sécurité pour éliminer toutes les ressources comme InputStream l'utilise pour fermer (ce qui encore une fois il n'y a aucune garantie qu'il sera br exécuter lorsque votre programme est encore en vie). Un autre endroit pour l'utiliser, il est tout en utilisant les indigènes où garbage collector n'a aucun contrôle.

Pour plus d'informations, visitez:

http://jatinpuri.com/?p=106

OriginalL'auteur Jatin
4

t1) finaliser la méthode est appelée lorsque l'objet est en cours d'ordures collectées, donc, si pas de GC est effectué, votre finaliseur ne peut pas être appelé. Vous devez appeler super tout simplement pour préserver le comportement prévu par l'implémentation de l'Objet.

t2) le moment exact où GC est effectuée dépend de beaucoup de facteurs comme: qui JVM que vous utilisez, les paramètres de réglage, d'un montant de gratuit tas, etc. Donc, il ne s'appuie pas seulement sur un tas de seuil. Vous pouvez également demander un GC à être effectué par le biais du Système.gc (), mais vous n'avez aucune garantie sur si et quand il sera réellement exécutée.
Vous pouvez trouver des détails sur la façon de configurer GC dans http://java.sun.com/performance/reference/whitepapers/tuning.html

OriginalL'auteur fpacifici
2

elle est appelée finalement ou pas du tout

fondamentalement la GC analyse le tas pour tout ce qui n'est pas accessible et exécute le finaliseur sur ceux (après quoi il a besoin de prouver à nouveau qu'il n'est pas accessible pour qu'il soit libéré)

cependant, il peut prendre un certain temps (pas défini de manière efficace et en fait dépend de comportement d'un programme) pour la GC pour trouver c'est pourquoi vous ne devriez pas vraiment compter sur elle pour disposer de données critiques

edit: comme pour les références circulaires, il fait la distinction entre les objets avec une méthode finalize et les objets, sans que l'un

pour un objet d'être libéré (supprimé à partir de la mémoire principale) il peut ne pas être accessible par n'importe quel code (ce qui inclut les finaliseurs qui ont encore besoin de courir)

lorsque 2 objets avec les finaliseurs sont admissibles à obtenir les finaliseurs exécuter le GC choisit arbitrairement un objet et le finaliseur sur elle et puis il peut exécuter l'autre objet

noter qu'un finaliseur pouvez exécuter tout les champs des objets peut ou ne peut pas être finalisé déjà

donc vous voulez dire l'ajout d'une méthode finalize() n'assure pas de bug de nettoyage? Pour l'e.g dans de tels cas, s'il existe un objet de fichier ouvert et je veux le nettoyer avant de l'objet de la tenue de ce fichier objet meurt alors méthode finalize() n'est d'aucune utilité, sauf si explicitement demandé.
yep c'est pourquoi close() est invoqué plus de finalize()
fonction close() dans le cas de l'objet? c'est ce que tu veux dire? Autant le dossier est examiné, c'est juste un exemple. Je suis inquiet au sujet de destructeur comme le comportement en JAVA
Je voulais dire close() de la Closeable interface, et de nombreuses fois finaliser est totalement inutile, ou il y a une solution explicite de l'élimination de ressources
Comme de Java 7, il y a la possibilité d'utiliser automatique de gestion des ressources (avec try), qui appelle automatiquement close() à la fin de l'essai, les bloquer. Ceci permettra de simplifier l'élimination des objets. Vous ne devez jamais utiliser finalize pour l'élimination de ressources.

OriginalL'auteur ratchet freak
-3

méthode finalize() est appelée automatiquement lors de la collecte des ordures. Système.gc() la méthode la force des appels garbage collector. mais nous aurons à détruire un objet avant.
exemple:
```
     public class Sample 
{
    public Sample()
    {
        System.out.println("Object created");
    }
    @Override
    public void finalize()
    {
        System.out.println("Object Destroyed");
    }
    public static void main(String args[])
    {
        Sample x=new Sample();
        Sample y=new Sample();

        x=null;
        y=null;

        System.gc();
    }
}
```
Système.gc() ne peut pas la force de la JVM pour exécuter le garbage collector. Il informe seulement de la JVM que les objets sont ouverts pour les collections.
System.gc() ne force pas la collecte des ordures. Il note que la collecte des ordures est souhaitée, mais la JVM va exécuter la collecte des ordures seulement quand il veut l'exécuter.
le point est ici que les objets doivent être "null" ou détruit pour voir le finaliser l'appel d'une méthode(comme indiqué dans le code ci-dessus).Sinon la méthode finalize sera appelé par la JVM chaque fois que la collecte des ordures a lieu .
Même lorsque System.gc() déclenche un garbage collection, il n'y a aucune garantie de voir l'effet de la finalize() méthode (en fait, c'est plutôt rare dans cet exemple), que la mise au point se produit de manière asynchrone après le garbage collector a mis en file d'attente les objets et ici, la JVM quitte juste après la collecte des ordures.

OriginalL'auteur anurag11

Vous devez vous connecter pour publier un commentaire.