Wann ist die finalize () - Methode aufgerufen, die in Java?

Im Allgemeinen ist es am besten nicht zu verlassen Sie sich auf finalize() zu tun Aufräumen etc.

Entsprechend der Javadoc (was es Wert wäre zu Lesen), es ist:

Vom garbage collector aufgerufen, der auf ein Objekt als garbage collection bestimmt, dass es keine weiteren Referenzen auf das Objekt.

Als Joachim wies darauf hin, dies vielleicht auch nie im Leben ein Programm, wenn das Objekt ist immer zugänglich.

Auch, dass der garbage collector nicht garantiert ist, laufen zu einem bestimmten Zeitpunkt. Im Allgemeinen, was ich versuche zu sagen ist finalize() ist wahrscheinlich nicht die beste Methode zu verwenden, im Allgemeinen, es sei denn, es ist etwas besonderes, Sie brauchen es für.

InformationsquelleAutor

protected void finalize() throws Throwable {}

• jede Klasse erbt die finalize() Methode aus
  java.lang.Objekt
• die Methode wird vom garbage collector aufgerufen, wenn es bestimmt
  keine weiteren Verweise auf das Objekt
  existieren
• das Objekt finalize-Methode führt keine Aktionen, aber es kann überschrieben werden, indem
  jede Klasse
• normalerweise sollte überschrieben werden, um clean-up-non-Java-Ressourcen ie schließen
  eine Datei

• wenn overridding finalize() es ist guter Programmierstil zu verwenden
  try-catch-finally-Anweisung und
  rufen Sie immer super.finalize(). Diese
  ist eine Sicherheitsmaßnahme, um sicherzustellen, dass Sie
  nicht versehentlich verpassen schließen
  Ressource, die von den Objekten aufrufen
  Klasse

  protected void finalize() throws Throwable {
       try {
           close();        //close open files
       } finally {
           super.finalize();
       }
   }

• jede Ausnahme, die ausgelöst durch finalize() während der garbage collection angehalten die
  die Fertigstellung ist ansonsten aber ignoriert

• finalize() ist nie mehr als einmal auf jedes Objekt

zitiert aus: http://www.janeg.ca/scjp/gc/finalize.html

Könnte man auch diesen Artikel:

• Objekt Vervollständigung und Bereinigung

InformationsquelleAutor XpiritO

Check-out Effektiv Java, 2. Auflage, Seite 27.
Punkt 7: Vermeiden Sie Finalizer

Finalizer sind unberechenbar, oft gefährlich und in der Regel unnötig. nichts tun, Zeit-kritisches in einem finalizer. nie
angewiesen auf einen finalizer zu aktualisieren kritische persistenten Zustand.

Zu beenden, eine Ressource, verwenden Sie try-finally statt:

//try-finally block guarantees execution of termination method
Foo foo = new Foo(...);
try {
    //Do what must be done with foo
    ...
} finally {
    foo.terminate(); //Explicit termination method
}

InformationsquelleAutor Hao Deng

Da gibt es eine uncertainity in den Aufruf von finalize () - Methode durch die JVM (nicht sicher, ob finalize (), die überschrieben würden, werden ausgeführt oder nicht), zum Zweck des Studiums der bessere Weg, um zu beobachten, was passiert, wenn finalize() aufgerufen wird, ist die Kraft, die JVM aufrufen, die garbage collection von command System.gc().

Speziell finalize() wird aufgerufen, wenn ein Objekt nicht mehr in Gebrauch. Aber wenn wir versuchen, es zu nennen, indem es neue Objekte gibt es keine Gewissheit, in der seine Forderung. Also mit Sicherheit wir schaffen ein null Objekt c die offensichtlich keine Zukunft mehr nutzen, damit wir das Objekt sehen c's finalize aufrufen.

Beispiel

class Car {

    int maxspeed;

    Car() {
        maxspeed = 70;
    }

    protected void finalize() {

    //Originally finalize method does nothing, but here we override finalize() saying it to print some stmt
    //Calling of finalize is uncertain. Difficult to observe so we force JVM to call it by System.gc(); GarbageCollection

        System.out.println("Called finalize method in class Car...");
    }
}

class Bike {

    int maxspeed;

    Bike() {
        maxspeed = 50;
    }

    protected void finalize() {
        System.out.println("Called finalize method in class Bike...");
    }
}

class Example {

    public static void main(String args[]) {
        Car c = new Car();
        c = null;    //if c weren`t null JVM wouldn't be certain it's cleared or not, null means has no future use or no longer in use hence clears it
        Bike b = new Bike();
        System.gc();    //should clear c, but not b
        for (b.maxspeed = 1; b.maxspeed <= 70; b.maxspeed++) {
            System.out.print("\t" + b.maxspeed);
            if (b.maxspeed > 50) {
                System.out.println("Over Speed. Pls slow down.");
            }
        }
    }
}

Ausgabe

    Called finalize method in class Car...
            1       2       3       4       5       6       7       8       9
    10      11      12      13      14      15      16      17      18      19
    20      21      22      23      24      25      26      27      28      29
    30      31      32      33      34      35      36      37      38      39
    40      41      42      43      44      45      46      47      48      49
    50      51Over Speed. Pls slow down.
            52Over Speed. Pls slow down.
            53Over Speed. Pls slow down.
            54Over Speed. Pls slow down.
            55Over Speed. Pls slow down.
            56Over Speed. Pls slow down.
            57Over Speed. Pls slow down.
            58Over Speed. Pls slow down. 
            59Over Speed. Pls slow down.
            60Over Speed. Pls slow down.
            61Over Speed. Pls slow down.
            62Over Speed. Pls slow down.
            63Over Speed. Pls slow down.
            64Over Speed. Pls slow down.
            65Over Speed. Pls slow down.
            66Over Speed. Pls slow down.
            67Over Speed. Pls slow down.
            68Over Speed. Pls slow down.
            69Over Speed. Pls slow down.
            70Over Speed. Pls slow down.

Hinweis - Auch nach dem Bedrucken bis zu 70 und nach dem Objekt b nicht benutzt wird, in das Programm, es ist die Unsicherheit, die b deaktiviert ist oder nicht von JVM, da "Namens finalize-Methode in der Klasse Bike..." ist nicht gedruckt.

InformationsquelleAutor techloris_109

Haben gerungen mit finalizer-Methoden in letzter Zeit (in der Reihenfolge zu entsorgen connection-pools während der Prüfung), muss ich sagen, dass finalizer fehlen viele Dinge. Mit VisualVM zu beobachten, als auch die Verwendung von schwachen Referenzen zu verfolgen, die tatsächliche Interaktion, die ich gefunden, dass folgende Dinge sind wahr in einem Java-8-Umgebung (Oracle JDK, Ubuntu-15):

• Abschließen ist nicht sofort aufgerufen, die Finalizer (GC Teil) individuell, besitzt die Referenz ausweichend
• Die Standard-Garbage-Collector-pools nicht erreichbar Objekte
• Finalize wird aufgerufen, in Massen zeigt auf eine Implementierung detail, dass es eine bestimmte phase der garbage collector entlastet die Ressourcen.
• Aufrufenden System.gc() ist oft nicht dazu führen, dass Objekte Finalisiert werden mehr, oft sind es nur die Ergebnisse in den Finalizer immer bewusst ein nicht erreichbares Objekt schneller
• Erstellen einen thread-dump fast immer das Ergebnis bei der Auslösung der finalizer aufgrund der hohen heap overhead während der Durchführung der heap-dump oder eine andere interne Mechanismus
• Fertigstellung Nähte, gebunden zu sein, entweder die Anforderungen an den Arbeitsspeicher (mehr Arbeitsspeicher) oder durch die Liste der Objekte, die markiert werden für die Finalisierung Wachstum einer bestimmten inneren Grenze. Also, wenn Sie haben eine Menge von Objekten, die immer abgeschlossen, die Finalisierung phase ausgelöst werden öfter und früher, wenn Sie im Vergleich mit nur ein paar
• Es gab Umstände, ein System.gc() ausgelöst finalize direkt, sondern nur wenn die Referenz wurde eine lokale und kurzen Leben. Dies könnte generation verwandt.

Letzten Gedanken

Finalize-Methode ist unzuverlässig, aber kann verwendet werden für eine einzige Sache. Sie können sicherstellen, dass ein Objekt geschlossen wurde oder entsorgt, bevor es wurde Müll gesammelt, wodurch es möglich ist, implementieren Sie einen fail-safe, wenn Objekte mit einer mehr komplizierten Lebens-Zyklus mit einem end-of-life Aktion richtig behandelt werden. Das ist der eine Grund, warum ich denken kann, ist es Wert, um um es zu überschreiben.

InformationsquelleAutor Martin Kersten

abschließen Methode ist nicht garantiert.Diese Methode wird aufgerufen, wenn das Objekt wird kommen für GC. Es gibt viele Situationen, in denen die Objekte möglicherweise nicht von der garbage Collection eingesammelt.

InformationsquelleAutor giri

Klasse, wo wir überschreiben der finalize-Methode

public class TestClass {    
    public TestClass() {
        System.out.println("constructor");
    }

    public void display() {
        System.out.println("display");
    }
    @Override
    public void finalize() {
        System.out.println("destructor");
    }
}

Die Chancen der finalize-Methode aufgerufen wird,

public class TestGarbageCollection {
    public static void main(String[] args) {
        while (true) {
            TestClass s = new TestClass();
            s.display();
            System.gc();
        }
    }
}

wenn der Speicher überlastet ist mit dump Objekte der gc-Aufruf finalize-Methode

laufen und die Konsole sehen, wo Sie nicht finden Sie die finalize-Methode aufgerufen wird, Häufig, wenn der Speicher immer überlastet dann die finalize-Methode wird aufgerufen werden.

InformationsquelleAutor pradeep

finalize() wird aufgerufen, kurz bevor die garbage-collection. Es wird nicht aufgerufen, wenn ein Objekt den Gültigkeitsbereich verlässt. Dies bedeutet, dass Sie nicht wissen, Wann oder sogar ob finalize() ausgeführt werden.

Beispiel:

Wenn Ihr Programm beenden, bevor der garbage collector auftreten, dann finalize() wird nicht ausgeführt. Daher sollte es als backup-Verfahren, um sicherzustellen, der richtige Umgang mit anderen Ressourcen, oder für spezielle Anwendungen, nicht als Mittel, die Ihr Programm verwendet in den normalen Betrieb.

InformationsquelleAutor AyukNayr