Wann wird die Methode finalize () in Java aufgerufen?

Ich muss wissen, wann die finalize()Methode in der aufgerufen wird JVM. Ich habe eine Testklasse erstellt, die beim Aufrufen der finalize()Methode in eine Datei schreibt, indem sie überschrieben wird. Es wird nicht ausgeführt. Kann mir jemand den Grund sagen, warum es nicht ausgeführt wird?

Im Allgemeinen ist es am besten, sich nicht auf finalize()Aufräumarbeiten usw. zu verlassen .

Laut Javadoc (was es wert wäre, gelesen zu werden) ist es:

Wird vom Garbage Collector für ein Objekt aufgerufen, wenn die Garbage Collection feststellt, dass keine Verweise mehr auf das Objekt vorhanden sind.

Wie Joachim betonte, kann dies im Leben eines Programms niemals passieren, wenn das Objekt immer zugänglich ist.

Außerdem kann nicht garantiert werden, dass der Garbage Collector zu einem bestimmten Zeitpunkt ausgeführt wird. Im Allgemeinen versuche ich zu sagen, dass dies finalize()wahrscheinlich nicht die beste Methode im Allgemeinen ist, es sei denn, Sie benötigen etwas Bestimmtes.

Die finalizeMethode wird aufgerufen, wenn ein Objekt Müll sammeln soll. Dies kann jederzeit geschehen, nachdem es für die Speicherbereinigung in Frage kommt.

Beachten Sie, dass es durchaus möglich ist, dass ein Objekt niemals Müll sammelt (und daher finalizeniemals aufgerufen wird). Dies kann passieren, wenn das Objekt niemals für gc berechtigt ist (da es über die gesamte Lebensdauer der JVM erreichbar ist) oder wenn zwischen dem Zeitpunkt, zu dem das Objekt berechtigt wird, und dem Zeitpunkt, zu dem die JVM nicht mehr ausgeführt wird, tatsächlich keine Speicherbereinigung ausgeführt wird (dies geschieht häufig mit simple Testprogramme).

Es gibt Möglichkeiten, die JVM anzuweisen, finalizeauf Objekten ausgeführt zu werden, die noch nicht aufgerufen wurden, aber ihre Verwendung ist auch keine gute Idee (die Garantien dieser Methode sind auch nicht sehr stark).

Wenn Sie sich finalizefür den korrekten Betrieb Ihrer Anwendung verlassen, machen Sie etwas falsch. finalizesollte nur zur Bereinigung von (normalerweise nicht Java) Ressourcen verwendet werden. Und das genau deshalb , weil die JVM nicht garantiert, dass finalizejemals ein Objekt aufgerufen wird.

protected void finalize() throws Throwable {}

• Jede Klasse erbt die finalize()Methode von java.lang.Object
• Die Methode wird vom Garbage Collector aufgerufen, wenn festgestellt wird, dass keine Verweise mehr auf das Objekt vorhanden sind
• Die Object finalize-Methode führt keine Aktionen aus, kann jedoch von jeder Klasse überschrieben werden
• Normalerweise sollte es überschrieben werden, um Nicht-Java-Ressourcen zu bereinigen, dh eine Datei zu schließen

• Beim Überschreiben ist finalize()es eine gute Programmierpraxis, eine try-catch-finally-Anweisung zu verwenden und immer aufzurufen super.finalize(). Dies ist eine Sicherheitsmaßnahme, um sicherzustellen, dass Sie nicht versehentlich das Schließen einer Ressource verpassen, die von den aufrufenden Objekten der Klasse verwendet wird

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

• Jede Ausnahme, die finalize()während der Speicherbereinigung ausgelöst wird, stoppt die Finalisierung, wird jedoch ansonsten ignoriert

• finalize() wird nie mehr als einmal auf einem Objekt ausgeführt

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

Sie können diesen Artikel auch überprüfen:

• Objektabschluss und Bereinigung

Die Java- finalize()Methode ist kein Destruktor und sollte nicht zur Verarbeitung der Logik verwendet werden, von der Ihre Anwendung abhängt. Die Java-Spezifikation besagt, dass es keine Garantie dafür gibt, dass die finalizeMethode während der Lebensdauer der Anwendung überhaupt aufgerufen wird.

Was Sie wahrscheinlich wollen, ist eine Kombination aus finallyund eine Bereinigungsmethode, wie in:

MyClass myObj;

try {
    myObj = new MyClass();

    // ...
} finally {

    if (null != myObj) {
        myObj.cleanup();
    }
}

Schauen Sie sich Effective Java, 2. Ausgabe, Seite 27 an. Punkt 7: Vermeiden Sie Finalizer

Finalizer sind unvorhersehbar, oft gefährlich und im Allgemeinen unnötig. Mach niemals etwas zeitkritisches in einem Finalizer. Verlassen Sie sich niemals auf einen Finalizer, um den kritischen dauerhaften Status zu aktualisieren.

Verwenden Sie stattdessen try-finally, um eine Ressource zu beenden:

// 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
}

Wann wird die finalize()Methode in Java aufgerufen?

Die Finalize-Methode wird aufgerufen, nachdem der GC festgestellt hat, dass das Objekt nicht mehr erreichbar ist, und bevor der vom Objekt verwendete Speicher tatsächlich zurückgefordert wird.

• Wenn ein Objekt niemals unerreichbar wird, finalize()wird es niemals aufgerufen.

• Wenn der GC nicht ausgeführt wird, wird er finalize()möglicherweise nie aufgerufen. (Normalerweise wird der GC nur ausgeführt, wenn die JVM entscheidet, dass wahrscheinlich genug Müll vorhanden ist, damit es sich lohnt.)

• Es kann mehr als einen GC-Zyklus dauern, bis der GC feststellt, dass ein bestimmtes Objekt nicht erreichbar ist. (Java-GCs sind normalerweise "Generationskollektoren" ...)

• Sobald der GC feststellt, dass ein Objekt nicht erreichbar und finalisierbar ist, wird es in eine Finalisierungswarteschlange gestellt. Die Finalisierung erfolgt normalerweise asynchron mit dem normalen GC.

^{(Die JVM-Spezifikation erlaubt einer JVM tatsächlich , niemals Finalizer auszuführen ... vorausgesetzt, sie beansprucht nicht den von den Objekten verwendeten Speicherplatz zurück. Eine auf diese Weise implementierte JVM wäre verkrüppelt / nutzlos, aber dieses Verhalten ist "erlaubt". .)}

Das Ergebnis ist, dass es unklug ist, sich auf die Finalisierung zu verlassen, um Dinge zu tun, die in einem bestimmten Zeitrahmen erledigt werden müssen. Es ist "Best Practice", sie überhaupt nicht zu verwenden. Es sollte einen besseren (dh zuverlässigeren) Weg geben, um das zu tun, was Sie mit der finalize()Methode versuchen .

Die einzige legitime Verwendung für die Finalisierung besteht darin, Ressourcen zu bereinigen, die mit Objekten verknüpft sind, die durch Anwendungscode verloren gegangen sind. Selbst dann sollten Sie versuchen, den Anwendungscode so zu schreiben, dass die Objekte überhaupt nicht verloren gehen. (Verwenden Sie beispielsweise Java 7+ Try-with-Resources, um sicherzustellen, dass dies close()immer aufgerufen wird ...)

Ich habe eine Testklasse erstellt, die in eine Datei schreibt, wenn die finalize () -Methode durch Überschreiben aufgerufen wird. Es wird nicht ausgeführt. Kann mir jemand den Grund sagen, warum es nicht ausgeführt wird?

Es ist schwer zu sagen, aber es gibt einige Möglichkeiten:

• Das Objekt wird nicht durch Müll gesammelt, da es noch erreichbar ist.
• Das Objekt wird nicht durch Müll gesammelt, da der GC nicht ausgeführt wird, bevor Ihr Test abgeschlossen ist.
• Das Objekt wird vom GC gefunden und vom GC in die Finalisierungswarteschlange gestellt. Die Finalisierung wird jedoch nicht abgeschlossen, bevor Ihr Test abgeschlossen ist.

Da es eine Unsicherheit beim Aufrufen der Methode finalize () durch JVM gibt (nicht sicher, ob finalized (), die überschrieben wird, ausgeführt wird oder nicht), ist es für Studienzwecke besser zu beobachten, was passiert, wenn finalize () aufgerufen wird Erzwingen Sie, dass die JVM die Garbage Collection per Befehl aufruft System.gc().

Insbesondere wird finalize () aufgerufen, wenn ein Objekt nicht mehr verwendet wird. Aber wenn wir versuchen, es durch Erstellen neuer Objekte aufzurufen, gibt es keine Gewissheit über seinen Aufruf. Aus Sicherheitsgründen erstellen wir ein nullObjekt, cdas offensichtlich keine zukünftige Verwendung hat. Daher sehen wir den cFinalize-Aufruf des Objekts .

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 Drucken von bis zu 70 und danach, wenn das Objekt b nicht im Programm verwendet wird, besteht die Unsicherheit, dass b von JVM gelöscht wird oder nicht, da "Aufgerufene Finalisierungsmethode in Klasse Bike ..." nicht gedruckt wird.

finalize druckt die Anzahl für die Klassenerstellung aus.

protected void finalize() throws Throwable {
    System.out.println("Run F" );
    if ( checkedOut)
        System.out.println("Error: Checked out");
        System.out.println("Class Create Count: " + classCreate);
}

Main

while ( true) {
    Book novel=new Book(true);
    //System.out.println(novel.checkedOut);
    //Runtime.getRuntime().runFinalization();
    novel.checkIn();
    new Book(true);
    //System.runFinalization();
    System.gc();

Wie du siehst. Die folgende Ausgabe zeigt, dass der GC zum ersten Mal ausgeführt wurde, wenn die Klassenanzahl 36 beträgt.

C:\javaCode\firstClass>java TerminationCondition
Run F
Error: Checked out
Class Create Count: 36
Run F
Error: Checked out
Class Create Count: 48
Run F

Nachdem ich in letzter Zeit mit Finalizer-Methoden gerungen habe (um Verbindungspools während des Testens zu entsorgen), muss ich sagen, dass dem Finalizer viele Dinge fehlen. Unter Verwendung von VisualVM zum Beobachten sowie unter Verwendung schwacher Referenzen zum Verfolgen der tatsächlichen Interaktion stellte ich fest, dass die folgenden Dinge in einer Java 8-Umgebung (Oracle JDK, Ubuntu 15) zutreffen:

• Finalize wird nicht sofort aufgerufen. Der Finalizer (GC-Teil) besitzt die Referenz einzeln
• Der Standard-Garbage Collector bündelt nicht erreichbare Objekte
• Finalize wird in großen Mengen aufgerufen und zeigt auf ein Implementierungsdetail, dass es eine bestimmte Phase gibt, in der der Garbage Collector die Ressourcen freigibt.
• Das Aufrufen von System.gc () führt häufig nicht dazu, dass Objekte häufiger finalisiert werden. Es führt lediglich dazu, dass der Finalizer schneller auf ein nicht erreichbares Objekt aufmerksam wird
• Das Erstellen eines Thread-Dumps führt fast immer dazu, dass der Finalizer aufgrund des hohen Heap-Overheads während der Ausführung des Heap-Dumps oder eines anderen internen Mechanismus ausgelöst wird
• Finalisierungsnähte müssen entweder an den Speicherbedarf (mehr Speicherplatz freigeben) oder an die Liste der Objekte gebunden werden, die für das Finalisieren eines bestimmten internen Grenzwerts markiert werden. Wenn also viele Objekte finalisiert werden, wird die Finalisierungsphase im Vergleich zu nur wenigen Objekten häufiger und früher ausgelöst
• Es gab Umstände, unter denen ein System.gc () eine Finalisierung direkt auslöste, jedoch nur, wenn die Referenz lokal und kurzlebig war. Dies kann generationsbezogen sein.

Letzter Gedanke

Die Finalisierungsmethode ist unzuverlässig, kann jedoch nur für eine Sache verwendet werden. Sie können sicherstellen, dass ein Objekt vor der Müllabfuhr geschlossen oder entsorgt wurde, um eine Ausfallsicherung zu implementieren, wenn Objekte mit einem komplexeren Lebenszyklus, der eine Aktion am Lebensende beinhaltet, korrekt behandelt werden. Das ist der einzige Grund, warum ich mir vorstellen kann, dass es sich lohnt, es zu überschreiben.

Ein Objekt kann für die Garbage Collection oder GC verwendet werden, wenn es nicht über Live-Threads oder statische Aktualisierungen erreichbar ist. Mit anderen Worten, Sie können sagen, dass ein Objekt für die Garbage Collection berechtigt ist, wenn alle Verweise null sind. Zyklische Abhängigkeiten werden nicht als Referenz gezählt. Wenn also Objekt A eine Referenz von Objekt B und Objekt B eine Referenz von Objekt A hat und keine andere Live-Referenz hat, können sowohl Objekt A als auch B für die Garbage Collection verwendet werden. Im Allgemeinen kann ein Objekt in folgenden Fällen in Java zur Speicherbereinigung verwendet werden:

1. Alle Referenzen dieses Objekts werden explizit auf null gesetzt, z. B. object = null
2. Das Objekt wird innerhalb eines Blocks erstellt und die Referenz verlässt den Gültigkeitsbereich, sobald die Steuerung diesen Block verlässt.
3. Das übergeordnete Objekt wird auf null gesetzt, wenn ein Objekt die Referenz eines anderen Objekts enthält und wenn Sie die Referenz des Containerobjekts auf null setzen, wird das untergeordnete oder enthaltene Objekt automatisch für die Speicherbereinigung zugelassen.
4. Wenn ein Objekt nur Live-Referenzen über WeakHashMap hat, kann es zur Speicherbereinigung verwendet werden.

Die Finalisierungsmethode kann nicht garantiert werden. Diese Methode wird aufgerufen, wenn das Objekt für die GC in Frage kommt. Es gibt viele Situationen, in denen die Objekte möglicherweise nicht durch Müll gesammelt werden.

Manchmal, wenn es zerstört wird, muss ein Objekt eine Aktion ausführen. Wenn ein Objekt beispielsweise über eine Nicht-Java-Ressource wie ein Dateihandle oder eine Schriftart verfügt, können Sie überprüfen, ob diese Ressourcen freigegeben sind, bevor Sie ein Objekt zerstören. Um solche Situationen zu verwalten, bietet Java einen Mechanismus namens "Finalisieren". Durch Abschluss können Sie bestimmte Aktionen definieren, die auftreten, wenn ein Objekt aus dem Garbage Collector entfernt werden soll. Um einer Klasse einen Finalizer hinzuzufügen, definieren Sie einfach die Methode finalize () . Die Java-Ausführungszeit ruft diese Methode immer dann auf, wenn ein Objekt dieser Klasse gelöscht werden soll. Innerhalb der Finalisierungsmethode ()Sie geben Aktionen an, die ausgeführt werden sollen, bevor ein Objekt zerstört wird. Der Garbage Collector wird regelmäßig nach Objekten durchsucht, die sich nicht mehr auf einen laufenden Status oder indirekt auf ein anderes Objekt mit Referenz beziehen. Bevor ein Asset freigegeben wird, ruft die Java-Laufzeit die Methode finalize () -Methode für das Objekt auf. Diefinalize () auf und hat die folgende allgemeine Form:

protected void finalize(){
    // This is where the finalization code is entered
}

Mit dem geschützten Schlüsselwort wird der Zugriff auf finalize () durch Code außerhalb seiner Klasse verhindert. Es ist wichtig zu verstehen, dass finalize () unmittelbar vor der Garbage Collection aufgerufen wird. Es wird beispielsweise nicht aufgerufen, wenn ein Objekt den Bereich verlässt. Dies bedeutet, dass Sie nicht wissen können, wann oder ob finalize () ausgeführt wird. Infolgedessen muss das Programm andere Mittel bereitstellen, um Systemressourcen oder andere vom Objekt verwendete Ressourcen freizugeben. Sie sollten sich nicht auf finalize () verlassen, um das Programm normal auszuführen.

Klasse, in der wir die Finalisierungsmethode überschreiben

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, dass die Finalisierungsmethode aufgerufen wird

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

Wenn der Speicher mit Dump-Objekten überladen ist, ruft gc die finalize-Methode auf

Führen Sie die Konsole aus, in der die Finalize-Methode nicht häufig aufgerufen wird. Wenn der Speicher überlastet wird, wird die Finalize-Methode aufgerufen.

Mit Java können Objekte eine Methode namens finalize () implementieren, die möglicherweise aufgerufen wird.

Die Methode finalize () wird aufgerufen, wenn der Garbage Collector versucht, das Objekt zu sammeln.

Wenn der Garbage Collector nicht ausgeführt wird, wird die Methode nicht aufgerufen.

Wenn der Garbage Collector das Objekt nicht erfasst und erneut versucht, es auszuführen , wird die Methode beim zweiten Mal nicht aufgerufen.

In der Praxis ist es sehr unwahrscheinlich, dass Sie es in realen Projekten verwenden.

Denken Sie daran, dass es möglicherweise nicht aufgerufen wird und dass es definitiv nicht zweimal aufgerufen wird. Die Methode finalize () kann null oder einmal ausgeführt werden.

Im folgenden Code erzeugt die Methode finalize () keine Ausgabe, wenn sie ausgeführt wird, da das Programm beendet wird, bevor der Garbage Collector ausgeführt werden muss.

Quelle

finalize()wird kurz vor der Speicherbereinigung aufgerufen. Es wird nicht aufgerufen, wenn ein Objekt den Gültigkeitsbereich verlässt. Dies bedeutet, dass Sie nicht wissen können, wann oder ob finalize()sie ausgeführt werden.

Beispiel:

Wenn Ihr Programm endet, bevor der Garbage Collector auftritt, finalize()wird es nicht ausgeführt. Daher sollte es als Sicherungsverfahren verwendet werden, um den ordnungsgemäßen Umgang mit anderen Ressourcen sicherzustellen, oder für Anwendungen mit besonderer Verwendung, nicht als Mittel, das Ihr Programm im normalen Betrieb verwendet.

Wie in https://wiki.sei.cmu.edu/confluence/display/java/MET12-J.+Do+not+use+finalizers ausgeführt ,

Es gibt keinen festen Zeitpunkt, zu dem Finalizer ausgeführt werden müssen, da der Ausführungszeitpunkt von der Java Virtual Machine (JVM) abhängt. Die einzige Garantie besteht darin, dass jede Finalizer-Methode, die ausgeführt wird, dies irgendwann tut, nachdem das zugeordnete Objekt nicht mehr erreichbar ist (erkannt während des ersten Zyklus der Speicherbereinigung) und irgendwann bevor der Speicherbereiniger den Speicher des zugeordneten Objekts zurückerobert (während des zweiten Zyklus des Speicherbereinigers). . Die Ausführung des Finalisierers eines Objekts kann beliebig lange verzögert werden, nachdem das Objekt nicht mehr erreichbar ist. Folglich ist das Aufrufen zeitkritischer Funktionen wie das Schließen von Dateihandles in der finalize () -Methode eines Objekts problematisch.

Versuchen Sie, dieses Programm zum besseren Verständnis auszuführen

public class FinalizeTest 
{       
    static {
        System.out.println(Runtime.getRuntime().freeMemory());
    }

    public void run() {
        System.out.println("run");
        System.out.println(Runtime.getRuntime().freeMemory());
    }

     protected void finalize() throws Throwable { 
         System.out.println("finalize");
         while(true)
             break;          
     }

     public static void main(String[] args) {
            for (int i = 0 ; i < 500000 ; i++ ) {
                    new FinalizeTest().run();
            }
     }
}