Question

我需要知道JVM中何时调用finalize()方法。我创建了一个测试类，当通过覆盖它来调用finalize()方法时，该测试类会写入文件。它没有被执行。谁能告诉我它没有执行的原因？

Answer 1

当对象即将收集垃圾时调用finalize方法。这可以在它有资格进行垃圾收集之后的任何时候。

请注意，对象永远不会被垃圾收集（因此永远不会调用finalize）。当对象永远不符合gc条件（因为它可以在JVM的整个生命周期内访问）或者在对象符合条件的时间和JVM停止运行的时间之间没有实际运行垃圾收集时（这通常发生在简单的情况下），就会发生这种情况。测试程序）。

有一些方法可以告诉JVM对尚未调用的对象运行finalize，但使用它们也不是一个好主意（该方法的保证也不是很强大））。

如果依靠finalize来正确操作您的应用程序，那么您做错了什么。 finalize应仅用于清理（通常是非Java）资源。而且完全因为JVM不保证在任何对象上都调用finalize。

Answer 2

一般情况下，最好不要依赖finalize()进行任何清理等。

根据Javadoc（值得一读），它是：

当垃圾收集确定没有对该对象的更多引用时，由对象上的垃圾收集器调用。

正如约阿希姆所指出的，如果对象始终可以访问，这可能永远不会发生在程序的生命周期中。

此外，无法保证垃圾收集器在任何特定时间运行。一般来说，我想说的是finalize()可能不是一般使用的最佳方法，除非你需要具体的东西。

Answer 3

protected void finalize() throws Throwable {}
每个类都继承了finalize()方法   java.lang.Object中

垃圾回收器在确定时调用该方法   不再引用该对象   存在

Object finalize方法不执行任何操作，但可以覆盖它   任何课程

通常应该重写它以清理非Java资源，即关闭   一个文件


如果覆盖finalize()使用a是一个很好的编程习惯   try-catch-finally语句和   总是打电话给super.finalize()。这个   是一项确保您做到的安全措施   不小心错过了关闭   调用对象使用的资源   班级

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



在垃圾回收期间finalize()抛出的任何异常都会停止   最终确定但被忽略


finalize()永远不会在任何对象上运行多次

引自：http://www.janeg.ca/scjp/gc/finalize.html

你也可以查看这篇文章：

Object finalization and cleanup

Answer 4

Java finalize()方法不是析构函数，不应该用于处理应用程序所依赖的逻辑。 Java规范声明无法保证在应用程序的实时时间内完全调用finalize方法。

您可能想要的是finally和清理方法的组合，如：

MyClass myObj;

try {
    myObj = new MyClass();

    // ...
} finally {

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

Answer 5

查看Effective Java，第2版第27页。 第7项：避免使用终结者

终结器是不可预测的，通常是危险的，而且通常是不必要的。永远不会在终结器中做任何时间关键的事情。决不依赖终结器来更新关键的持久状态。

要终止资源，请改用try-finally：

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

Answer 6

Java中调用的finalize()方法是什么时候？

在GC检测到对象不再可访问之后，以及在它实际回收对象使用的内存之前，将调用finalize方法。

如果某个对象永远无法访问，则永远不会在其上调用finalize()。
如果GC未运行，则可能永远不会调用finalize()。（通常情况下，只有当JVM确定可能存在足够的垃圾才能使其值得时，GC才会运行。）
在GC确定特定对象无法访问之前，可能需要多个GC周期。（Java GCs通常是“世代”收藏家......）
一旦GC检测到某个对象无法访问并可终结，它就会置于终结队列中。终结通常与普通GC异步发生。

^{（JVM规范实际上允许 JVM 从不运行终结器...只要它不回收对象使用的空间。以这种方式实现的JVM将会瘫痪/无用，但这种行为是“允许的”。）}

结果是依靠最终化做必须在确定的时间范围内完成的事情是不明智的。根本不使用它们是“最佳实践”。应该有一种更好（即更可靠）的方式来做你在finalize()方法中尝试做的任何事情。

最终确定的唯一合法用途是清理与应用程序代码丢失的对象相关联的资源。即使这样，您也应该尝试编写应用程序代码，以便它不会丢失对象。（例如，使用Java 7+ try-with-resources 以确保始终调用close() ...）

我创建了一个测试类，当通过覆盖它调用finalize（）方法时，该测试类会写入文件。它没有被执行。谁能告诉我它没有执行的原因？

很难说，但有一些可能性：

该对象不会被垃圾收集，因为它仍然可以访问。
对象未进行垃圾回收，因为GC在测试完成之前未运行。
GC找到该对象并由GC放置在终结队列中，但在测试完成之前未完成最终确定。

Answer 7

由于JVM调用finalize（）方法存在不确定性（不确定是否会执行被覆盖的finalize（）），出于研究目的，更好地观察调用finalize（）时会发生什么，是强制JVM通过命令System.gc()调用垃圾收集。

具体来说，当一个对象不再使用时，会调用finalize（）。但是当我们试图通过创建新对象来调用它时，它的调用并不确定。因此，为了确定，我们会创建一个null对象c，显然没有将来使用，因此我们会看到对象c的最终调用。

示例

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."); } } } }

<强>输出

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.

注意 - 即使在打印到70之后并且在程序中没有使用对象b之后，仍然存在jVM清除b的不确定性，因为＆＃34;被称为finalize方法class Bike ......＆＃34;没有打印。

Answer 8

finalize将打印出类创建的计数。

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);
}

主

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

如你所见。以下输出显示gc在班级计数为36时第一次执行。

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

Answer 9

最近与终结器方法搏斗（为了在测试期间配置连接池），我不得不说终结器缺少很多东西。使用VisualVM观察以及使用弱引用来跟踪实际的交互，我发现Java 8环境中的事情是正确的（Oracle JDK，Ubuntu 15）：

Finalize不会立即被调用，终结者（GC部分）单独拥有参考资料
默认垃圾收集器池无法访问的对象
批量调用Finalize，指向垃圾收集器释放资源的某个阶段的实现细节。
调用System.gc（）通常不会导致对象被更频繁地终结，只会导致Finalizer更快地意识到无法访问的对象
创建线程转储几乎总是导致在执行堆转储或其他内部机制期间由于高堆开销而触发终结器
终结接缝受内存要求（释放更多内存）或被标记的对象列表的限制，以便最终确定某个内部限制。因此，如果您有很多对象最终确定，那么与少数对象相比，将更频繁和更早地触发终结阶段
有些情况下，System.gc（）会直接触发终结，但前提是该引用是本地和短期生活。这可能与代相关。

最后的想法

Finalize方法不可靠，但只能用于一件事。您可以确保在对象被垃圾收集之前关闭或处置，从而可以实现故障安全，如果正确处理具有更复杂生命周期的对象的生命周期。这就是我能想到的一个原因，为了覆盖它是值得的。

Answer 10

如果某个对象无法从任何活动线程或任何静态引用访问，则该对象符合垃圾收集或GC的条件，换句话说，如果一个对象的所有引用都为空，则可以说该对象符合垃圾回收条件。循环依赖项不计入引用，因此如果对象A具有对象B的引用而对象B具有对象A的引用并且它们没有任何其他实时引用，则对象A和B都将有资格进行垃圾收集。通常，在以下情况下，对象有资格在Java中进行垃圾收集：

该对象的所有引用都明确设置为null，例如object = null
在块内创建对象，并且一旦控制退出该块，引用就会超出范围。
父对象设置为null，如果对象保存另一个对象的引用，并且当您将容器对象的引用设置为null时，子对象或包含对象将自动符合垃圾回收的条件。
如果一个对象只有WeakHashMap的实时引用，它将有资格进行垃圾回收。

Answer 11

无法保证

finalize 方法。当对象符合GC条件时，将调用此方法。在许多情况下，对象可能不会被垃圾收集。

Answer 12

有时当它被销毁时，对象必须采取行动。例如，如果对象具有非Java资源（如文件句柄或字体），则可以在销毁对象之前验证是否已释放这些资源。为了管理这种情况，java提供了一种称为“终结”的机制。通过最终确定，您可以定义在即将从垃圾收集器中删除对象时发生的特定操作。要为类添加终结器，只需定义 finalize（）方法即可。只要要删除该类的对象，Java执行时就会调用此方法。在finalize 方法（）中，指定在销毁对象之前要执行的操作。定期搜索垃圾收集器以查找不再引用任何运行状态的对象或间接搜索任何其他引用的对象。在发布资产之前，Java运行时会在对象上调用 finalize（）方法。 finalize（）方法具有以下一般形式：

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

使用 protected 关键字，可防止通过其类外的代码访问 finalize（）。重要的是要理解 finalize（）就在垃圾收集之前调用。例如，当对象离开范围时，不会调用它。这意味着您无法知道何时或是否将执行 finalize（）。因此，程序必须提供其他方法来释放对象使用的系统资源或其他资源。 您不应该依赖 finalize（）来正常运行程序。

Answer 13

我们覆盖终结方法的类

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

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

调用finalize方法的可能性

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

当内存超载转储对象时，gc将调用finalize方法

运行并查看控制台，在那里你没有发现频繁调用的finalize方法，当内存过载时会调用finalize方法。

Answer 14

Java允许对象实现一个名为finalize（）的方法   可能会被召唤。
     如果垃圾收集器试图调用
finalize（）方法   收集对象。

如果垃圾收集器没有运行，则该方法不会被调用。

如果垃圾收集器无法收集对象并尝试运行   再次，该方法第二次没有被调用。

在实践中，您极不可能在实际项目中使用它。

请记住，它可能不会被调用，而且它肯定会被调用   不会被叫两次。 finalize（）方法可以运行零或一个   时间。

在下面的代码中，finalize（）方法在我们生成时没有输出   自从程序退出之前运行它，然后才需要运行它   垃圾收集器。

Source

Answer 15

在垃圾收集之前调用

finalize()。当对象超出范围时，不会调用它。这意味着您无法知道何时或甚至是否会执行finalize()。

示例：

如果您的程序在垃圾收集器发生之前结束，则finalize()将不会执行。因此，它应该用作备份程序，以确保正确处理其他资源，或用于特殊用途应用程序，而不是程序在正常操作中使用的方法。

Answer 16

https://wiki.sei.cmu.edu/confluence/display/java/MET12-J.+Do+not+use+finalizers中指出，

没有终结器必须执行的固定时间，因为执行时间取决于Java虚拟机（JVM）。唯一的保证是，在关联对象变得不可访问之后（在垃圾回收的第一个周期中检测到）和垃圾回收器回收关联对象的存储前的某个时间（在垃圾回收器的第二个周期期间），任何执行的终结器方法都将执行此操作。。在对象变得不可访问之后，对象的终结器的执行可能会延迟任意长时间。因此，调用时间紧迫的功能，例如在对象的finalize（）方法中关闭文件句柄是有问题的。

Answer 17

尝试运行此程序以便更好地理解

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();
            }
     }
}

什么时候在Java中调用finalize（）方法？

17 个答案: