1

我有以下与 finalize() 方法和 Java 的垃圾收集有关的问题。

  1. 有没有一种方法可以强制使用 finalize() 方法？
    JDK弃用以下方法的原因是什么？

    Runtime.runFinalizersOnExit(true);

  2. 除了上面的问题，我正在阅读文章http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html。在此，请参见第 5 点，作者说 finalize() 在调用垃圾收集器之前被调用。那么这件事肯定会发生吗？我的意思是在执行垃圾收集器方法之前总是调用 finalize() 方法吗？

  3. 假设我的堆中有很多垃圾，但没有执行垃圾收集器。那么这不是JVM的不良行为或缺陷吗？

  4. 由于没有发生垃圾收集，它如何降低我的应用程序的性能？

4

2 回答 2

0

由于这些原因，您根本不应该使用 finalize 。除了给定的答案，我还给你一些示例代码。它证明，作为程序员，您通常无法确保 finalize 会运行。示例 1 和 5 无关紧要，因为它们很少重要。但是 3、4 和 5 有时可以。

请阅读关于PhantomReferences 的信息。PhantomReference如果不提及s ，任何关于 finalize 的问题的答案都是不完整的。您可以在非守护线程中处理这些，并确保 JVM 在处理完所有内容之前不会退出。

package com.example.foo;

import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.util.LinkedList;
import java.util.List;

/**
 * Demonstration of failing finalize-implementations. Just run main, wait and see that it does not
 * actually print any messages other than "good bye!", even though there are 5
 * <code>System.out.println(...)</code> in the finalize-methods.
 * 
 * <p>
 * However, finalize is run even if the instance was not created properly (Exception in
 * constructor). This may lead to problems, as the resources to close might not even exist.
 * 
 * <p>
 * This answers this question: "Why is there no guarantee that {@link Object#finalize()} is run?"
 * 
 * <p>
 * If you want an answer to the question: "Then what can I do to properly use finalize()?" <br/>
 * The answer is: Don't! <br/>
 * Not just because of the problems presented here. There are actually more problems! <br/>
 * Here's a better alternative: http://claude-martin.ch/java-cleanup/
 */
public class SomeClass {

  /**
   * Finalize of Object is not invoked by some JVMs because it is known to be empty. This is
   * relevant if you thought you could use a tools that can intercept invocation of finalize (as in
   * aspect-oriented programming).
   */
  static final class Finalize1 {
    // no finalize
  }

  /** Class and method not final. */
  static class Finalize2 {
    @Override
    protected void finalize() throws Throwable {
      // not final -> extending class doesn't have to call this method.
      System.out.println("Finalize2");
    }
  }

  /**
   * Finalize allocates new data and fails. GC runs it but you have no guarantee that the JVM can
   * run it successfully.
   */
  static final class Finalize3 {
    @Override
    protected void finalize() throws Throwable, OutOfMemoryError {
      // What if memory is already running out?
      // Chances are high - why else would gc be running?
      // Then even a small array could fail:
      byte[] bytes = new byte[Integer.MAX_VALUE];
      // OutOfMemoryError was thrown!
      System.out.println("Finalize3 " + bytes[0]);
      // Also not run:
      super.finalize();
    }
  }

  static Finalize4 finalize4;

  /**
   * This is just to show that you, as the author of a class, can not prevent that an instance is
   * referenced from a static field. This is also true for all data structures that exist until the
   * JVM exits.
   */
  static final class Finalize4 {
    @Override
    protected void finalize() throws Throwable {
      System.out.println("Finalize4");
    }
  }

  /**
   * JVM could end abruptly. Again, you have no control over this when you write a class.
   */
  static final class Finalize5 {
    @Override
    protected void finalize() throws Throwable {
      System.out.println("Finalize5");
    }
  }

  /** Runs Garbage Collection. */
  static void gc(int n) {
    final List<byte[]> list = new LinkedList<>();
    try {
      while (true)
        list.add(new byte[1024 * 1024]);
    } catch (OutOfMemoryError e) {
      // Now GC is needed...
    }
    for (int i = 0; i < n; i++) {
      System.gc();
      try { // Give it time:
        Thread.sleep(100);
      } catch (InterruptedException e) {
      }
    }
  }

  public static void main(String[] args) {
    gc(0); // fills memory

    // 1) no finalize implemented:
    new Finalize1();

    // 2) no call to super.finalize():
    new Finalize2() {
      private OutputStream resource = new ByteArrayOutputStream();

      @Override
      protected void finalize() throws Throwable {
        // Not calling super.finalize() !
        this.resource.close();
      }
    };

    // 3) Failing finalize:
    new Finalize3();

    // 4) static reference:
    finalize4 = new Finalize4();

    // Now let's try to get rid of them:
    gc(20);

    // 5) No time:
    new Finalize5();
    System.out.println("good bye!");
    System.exit(0);
  }

}
于 2014-07-23T07:22:12.803 回答
0

该finalize方法可能永远不会真正被调用，因此任何肯定需要运行的关键清理代码都应该放在其他地方。您可能应该自己管理这个 - 当您完成一个持有某些资源的对象时，明确地进行清理（close例如实现一个方法）。

于 2014-03-13T08:55:20.677 回答