第7条：避免使用终结方法

第7条：避免使用终结方法(finalizer)

---

缺点

    终结方法(finalizer)通常是不可预测的，也是很危险的，一般情况下是不必要使用它的。使用终结方法会导致行为不稳定，降低性能，以及可移植性的问题，不过终结方法也有其可用之处。

    在C++中存在着析构器(destructors)这种帮助回收对象占用资源时的常规方法，是构造器所必需的对应物。但是Java中的终结方法作用并不等同于析构器，当一个对象变成不可达到的状态时，也就是没有引用指向这个具体对象时，垃圾回收器会回收与该对象相关联的存储空间。

    1. 终结方法的缺点在于不能保证会被及时地执行。

    从一个对象变为不可达到的状态开始，到其终结方法被执行，所花费的这段时间是任意长的。这意味着，注重时间的任务不应该由终结方法来完成。例如，在终结方法里面关闭已经打开了的文件，文件处于打开的状态时会占用着内存空间，由于JVM会延迟执行终结方法，所以大量的文件会保留在打开状态，当一个程序不能打开文件的时候，它可能运行失败。

    Java语言规范不仅不保证终结方法会被及时的执行，而且根本就不保证它们会被执行。当一个程序中止的时候，某些已经无法访问的对象上的终结方法却根本没有得到执行。

    不要被System.gc和System.runFinalization这两个方法所诱惑了，它们确实增加了终结方法被执行的机会，但是他们不保证终结方法一定会被执行。唯一声称保证终结方法被执行的方法是System.runFinalizersOnExit，以及Runtime.runFinalizerOnExit，但是由于两个方法都有缺陷，已经被废弃掉了。

    2. 正常情况下，未被捕捉的异常将会使所在线程停止，并且打出stack trace，但是如果异常发生在了终结方法之中，不仅线程不会终结，甚至连警告都打不出来

    如果在执行终结方法的过程中有异常被抛出来了，但是程序没有进行捕捉处理，这种异常可能被忽略掉并且这个对象的终结过程也会被终止，终结方法之后的工作也无法进行下去。这就有可能导致对象处于一种被破坏的状态(a corrupt state)，如果另外一个线程企图使用这种被破坏的对象可能产生不确定的行为。

---

替代方法

    如果类的对象中封装的资源确实需要终止，则可以用下面的方法来替代使用终结方法。只需提供一个显示的终结方法，并且要求该类的客户端在每个实例不再有用的时候调用这个方法。值得一提的细节是，该实例必须记录下自己是否已经被终止并不再有效了：显示的终结方法执行之后必须在一个私有域中记录下”该实例不再有效”，可以是一个boolean也可以是其他的。为了防止其他方法或者线程来调用这个已经被终结的对象之后造成不可预知的结果。显示终结方法的典型例子肯定已经见过不少了，在InputStream以及OutputStream上的close()方法。

    显示的终止方法通常与try-finally结构结合以来使用，确保及时终止。在finally子句内部调用显示的终止方法，可以保证即使在使用对象的时候有异常抛出，终止方法也会进行的：

A a = new A();
try {
    System.out.println(a.getClass());
} finally {
    a.terminate();
}

好处

    终结方法- -什么用都没有，当时把它弄出来是干嘛使得呢。它们有两种合法的用途。第一种用途是，当对象的所有者忘记调用前面段落中建议的显示终结方法时，可以充当“安全网”的作用，做好第二道防御的措施。虽然这样做并不能保证会及时的调用，但是迟一点执行总比没有执行好吧= =。

    终结方法第二种合理的用途与对象的本地对等体(native peer)有关。本地对等体是一个本地对象(native object),普通对象通过本地方法委托给一个本地对象。因为本地对等体不是一个普通的Java对象，所以垃圾回收器并不会知道它，当它的Java对等体被回收的时候，它不会被回收。在本地对等体并不拥有关键资源的前提下，终结方法正是执行这项任务最合适的工具。如果本地对等体拥有必须被马上终止的资源，那么该类就应该有一个显示的终结方法。

    值得注意的是，“终结方法链”并不会被自动的执行。如果类有终结方法，并且子类覆盖了终结方法，则需要手动的去调用超类的终结方法。可以这么使用来确保父类的终结方法也会得到调用：

@Override
protected void finalize() throws Throwable {
    try {
        // .....    
    } finally {
        super.finalize();
    }
}

    如果子类覆盖了超类的终结方法，但是忘了手动的调用终结方法，那么超类的终结方法将永远也不会被调用到。要防范这样粗心大意或者恶意的子类也是有可能的，代价就是为每个将每个将被终结的对象创建一个附加的对象。不是把终结方法放在要求终结处理的类中，而是放在一个匿名的类中，该匿名类的唯一用途就是终结它的外围实例(enclosing instance)。该匿名类的单个实例被成为终结方法守卫者(finalizer guardian)，外围类的每个实例都会创建这样一个守卫者。外围实例在私有实例域中保存着一个对终结方法守卫者的唯一引用，因此终结方法守卫者与外围实例可以同时启动终结过程。当守卫者被终结的时候，它执行外围实例所期望的终结行为，就好像它是终结方法外围让对象上的一个方法一样,看下面这个例子，虽然不推荐用System.runFinalizersOnExit(true);，但是为了例子演示方便，还是用了= =，orz求原谅。

class A {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("A --- finalize");
    }
}

class B extends A {

    private A a = new A();

    @Override
    protected void finalize() throws Throwable {
        System.out.println("B --- finalize");
    }

    private final Object finalizeGurdian = new Object(){
        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("finalizeGurdian --- finalize");
        }
    };
}

class C extends B {
    @Override
    protected void finalize() throws Throwable {
        //在这里调用父类的终结方法，如果有这句话，B的finalize才会被调用
        //super.finalize();
        System.out.println("C --- finalize");
    }
}


public class Main {
    public static void main(String[] args) {
        C c = new C();
        System.runFinalizersOnExit(true);
    }
}

    通过上面的例子我们可以看出，只要有finalize()函数的类里面存在着其他类的引用，例如上面的C类里面存放着一个A类的实例引用和一个B类的实例引用，则它们都会被调用到finalize()方法，唯独被覆盖了的父类不会自动调用finalize()，需要我们手动super.finalize()。

    总之除非是作为资源回收处理的第二道防线(安全网)或者是为了终结非关键的资源，否则请不要使用终结方法。如果没办法真的使用了finalize，别忘记了调用super.finalize()。还应考虑是否使用终结方法守卫者，使未调用super.finalize()方法的类的父类的终结方法也会被执行。