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

Question

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

Answer 1

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

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

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

如果您依靠 finalize 来使应用程序正确运行，那么您就做错了。 finalize 应该仅用于清理（通常是非Java）资源。正是如此，因为 JVM 不保证在任何对象上调用 Finalize。

Answer 2

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

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

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

正如 Joachim 指出的，如果对象始终可访问，那么在程序的生命周期中这可能永远不会发生。

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

Answer 3

protected void Finalize() throws Throwable {}

• 每个类都继承了 finalize() 方法
  java.lang.Object
• 垃圾收集器在确定时调用该方法
  不再引用该对象
  存在
• 对象的finalize方法不执行任何操作，但它可以被覆盖
  任何类别
• 通常应该重写它来清理非 Java 资源，即关闭
  一个文件

• 如果重写finalize()，那么使用
  try-catch-finally 语句并
  始终调用 super.finalize()。这
  是确保您这样做的安全措施
  不要无意中错过关闭
  对象调用所使用的资源
  类

  protected void Finalize() throws Throwable {
       尝试 {
           关闭（）; // 关闭打开的文件
       } 最后 {
           super.finalize();
       }
   }
  

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

• finalize() 绝不会在任何对象上运行多次

finalize() 永远不会在引用自以下内容的 ：http://www.janeg.ca/scjp/gc/finalize.html

您还可以查看这篇文章：

• 对象完成和清理

Answer 4

Java finalize() 方法不是析构函数，不应该用于处理应用程序所依赖的逻辑。 Java 规范规定，不保证在应用程序的生命周期内调用 Finalize 方法。

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

MyClass myObj;

try {
    myObj = new MyClass();

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

这将正确处理MyClass() 构造函数抛出异常时的情况。

Answer 5

查看《Effective Java》第二版第 27 页。
第 7 项：避免终结器

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

要终止资源，请使用 try-finally 代替：

// try-finally 块保证终止方法的执行
Foo foo = new Foo(...);
尝试 {
    // 做 foo 必须做的事情
    ...
} 最后 {
    foo.terminate(); // 显式终止方法
}

Answer 6

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

Finalize方法将在GC检测到对象不再可达之后、实际回收对象使用的内存之前被调用。

• 如果一个对象永远不会变得无法访问，则永远不会对其调用 finalize()。

• 如果 GC 不运行，则可能永远不会调用 finalize()。 （通常，GC 仅在 JVM 认为可能有足够的垃圾值得执行时才运行。）

• 在 GC 确定某个特定对象无法访问之前，可能需要多个 GC 周期。 （Java GC 通常是“分代”收集器...）

• 一旦 GC 检测到某个对象无法访问且可终结，它就会被放入终结队列中。终结通常与普通 GC 异步发生。

^{（JVM 规范实际上允许 JVM 从不运行终结器...前提是它不回收对象使用的空间。以这种方式实现会被削弱/无用，但如果这种行为是“允许的”。）}

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

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

---

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

这很难说，但有几种可能性：

• 该对象没有被垃圾回收，因为它仍然是可访问的。
• 该对象不会被垃圾回收，因为 GC 在测试完成之前不会运行。
• GC 找到该对象并将其放入终结队列中，但在测试完成之前终结尚未完成。

Answer 7

由于 JVM 调用 Finalize() 方法存在不确定性（不确定被重写的 Finalize() 是否会被执行），出于研究目的，观察调用 Finalize() 时发生的情况的更好方法是通过命令 System.gc() 强制 JVM 调用垃圾回收。

具体来说，当对象不再使用时调用 Finalize()。但是当我们尝试通过创建新对象来调用它时，它的调用并不确定。因此，为了确定性，我们创建了一个 null 对象 c，它显然没有未来的用途，因此我们看到了对象 c 的 Finalize 调用。

示例

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 不再在程序中使用，也不确定 b 是否被清除或不由 JVM 执行，因为不会打印“Called Finalize method in class Bike...”。

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

你所见。以下输出显示当类计数为 36 时第一次执行 gc。

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 不会立即调用 Finalizer（GC 部分）单独拥有引用难以捉摸的是
• ，默认的垃圾收集器池无法访问的对象
• Finalize 被批量调用，指向垃圾收集器在某个阶段释放资源的实现细节。
• 调用 System.gc() 通常不会导致对象更频繁地被终结，它只会导致终结器更快地意识到无法访问的对象
• 。堆转储或其他一些内部机制
• 最终化接缝受内存要求（释放更多内存）或被标记为最终化增长的特定内部限制的对象列表的约束。因此，如果有很多对象被终结，那么与只有少数对象相比，终结阶段将被更频繁、更早地触发。 在
• 某些情况下，System.gc() 会直接触发终结，但前提是引用是本地且短暂的。这可能与世代有关。

最终想法

Finalize 方法不可靠，但只能用于一件事。您可以确保对象在垃圾收集之前已关闭或处置，从而如果正确处理涉及生命周期结束操作的更复杂生命周期的对象，则可以实现故障安全。这是我能想到的一个值得超越它的原因。

Answer 10

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

1. 该对象的所有引用显式设置为 null，例如 object = null
2. 对象在块内创建，一旦控制退出该块，引用就会超出范围。
3. 父对象设置为 null，如果一个对象持有另一个对象的引用，并且当您将容器对象的引用设置为 null 时，子对象或包含的对象将自动符合垃圾回收的条件。
4. 如果一个对象仅通过 WeakHashMap 具有实时引用，则它将有资格进行垃圾回收。

Answer 11

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

Answer 12

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

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

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

Answer 13

JDK 18 的最新消息

根据 JEPS 421 在 openjdk 18 上交付了最终版本，因此提供了以下功能： finalize() 方法将被标记为 deprecated(forRemoval=true) ，这意味着在 jdk 18 之后的某个更高版本中将永久删除。

从 jdk 18 开始，一个新命令 -行选项 --finalization=disabled 禁用所有地方的终结机制，即使对于 jdk 本身内部的声明也是如此。

这也与这里的问题相关，因为计划删除它的原因是它包含一些主要缺陷。这些缺陷之一是，从对象变得无法访问到调用其终结器之间可能需要很长的时间。 GC 确实不保证任何终结器都会被调用。

Answer 14

我们重写finalize方法的类

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 15

finalize() 在垃圾回收之前调用。当对象超出范围时不会调用它。这意味着您无法知道finalize()何时或是否会被执行。

示例：

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

Answer 16

Java 允许对象实现一个名为 Finalize() 的方法
这可能会被调用。

如果垃圾收集器尝试执行操作，finalize() 方法就会被调用
收集物体。

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

如果垃圾收集器未能收集对象并尝试运行
再说一次，该方法不会在第二次被调用。

实际上，您不太可能在实际项目中使用它。

请记住，它可能不会被调用，但它肯定会被调用
不会被叫两次。 Finalize() 方法可以运行零个或一个
时间。

在下面的代码中，当我们执行finalize()方法时，finalize()方法不会产生任何输出
运行它，因为程序在需要运行之前退出
垃圾收集器。

来源

Answer 17

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

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

Answer 18

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

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