【JAVA优化编程】内存管理之——（3）Java中的析构方法finalize

3  Java中的析构方法finalize

    在C++程序设计中有构造与析构的概念，并且是内存管理技术中相当重要的一部分，而在Java语言中只有构造的概念，却没有析构的概念。这是因为理论上JVM负责对象的析构工作也就是之前讲到的垃圾回收的概念，其实Java语言中的finalize 方法类似于C++语言中的析构函数。finalize 方法是Java语言根基类Object类的一个方法，这个方法是保护类性质的方法（protected），由于在Java应用中开发的所有类都为Object的子类，因此用户类都从Object对象中继承了该方法。因此我们在子类中可以调用父类中的finalize 方法，由于finalize 方法没有自动实现递归调用，我们必须手动实现，因此finalize函数的最后一个语句通常是super.finalize()。通过这种方式，我们可以实现从下到上finalize 的调用，即先释放用户类自身的资源，然后再释放父类的资源。通常我们可以在finalize 方法中释放一些不容易控制、并且非常重要的资源，例如：一些I/O的操作，数据的连接。这些资源的释放对整个应用程序是非常关键的。

    由于GC调用finalize的时间是不确定的，有时我们需要通过其他的手段来释放程序中所占用的系统资源，比如自己在类中声明一个destroy()方法，在这个方法中添加释放系统资源的处理代码，当你使用完该对象后可以通过调用这个destroy()方法来释放该对象内部成员占用的系统资源。并且最好在类的finalize 方法中添加资源释放代码，这样做更为保险、安全。在类深度继承的情况下，这种方法显得就更为有效，我们可以通过递归调用destroy的方法在子类被销毁的时候释放父类所占用的资源，例如下面的代码：

    原始基类A

public class A {

    Object a = null;

    public A() {
        a = new Object();
        System.out.println("创建a对象");
    }

    protected void destroy() {
        System.out.println("释放a对象");
        a = null;
        // 释放自身所占用的资源
    }

    protected void finalize() throws java.lang.Throwable {
        destroy();
        super.finalize(); // 递归调用超类中的finalize方法
    }
}

    一级子类B

>public class B extends A {

    Object b = null;

    public B() {
        b = new Object();
        System.out.println("创建b对象");
    }

    protected void destroy() {
        b = null;
        // 释放自身所占用的资源
        System.out.println("释放b对象");
        super.destroy();
    }

    protected void finalize() throws java.lang.Throwable {
        destroy();
        super.finalize(); // 递归调用超类中的finalize方法
    }
}

    二级子类C

>public class C extends B {

    Object c = null;

    public C() {
        c = new Object();
        System.out.println("创建c对象");
    }

    protected void destroy() {
        c = null;
        // 释放自身所占用的资源
        System.out.println("释放c对象");
        super.destroy();
    }

    protected void finalize() throws java.lang.Throwable {
        destroy();
        super.finalize(); // 递归调用超类中的finalize方法
    }
}

    上面的三个类的继承关系是非常明晰的： A->B->C，类A是原始基类（这是一种习惯叫法），类B继承了类A，类C又继承了类B。其实类A并不是正真意义上的原始基类，之前我们已经提到过Java语言中的原始基类是Object类，尽管我们并没有显式的声明，但这已经是系统约定俗成的了。

    为了简单清楚地说明问题，我们在这三个类中分别声明了3个方法，用来论证上面所讲解的知识点，在类A中在其构造器中初始化了一个对象a，在destroy方法中通过a = null;释放其自身所占用的资源。在finalize方法中我们再次调用了destroy方法用来释放其自身所占用的资源，然后调用其超类Object的finalize方法，这是我们以上所提到的“双保险”的内存释放方法；类B与类C的结构与类A极为相似，它们除了释放自身的所占用资源外，它们还在其对应的方法中调用其超类的destroy方法与finalize方法，用来释放超类所占用的资源。

    如在类B中调用其超类A的destroy方法与finalize方法，在类C中调用其超类B的destroy方法与finalize方法。但是类A与类B、类C有一点不同的是在其destroy方法中它没有super.destroy();语句，这是因为其超类Object并没有destroy方法。下面看一下当我们调用初始化与销毁类C时会有什么样的情况发生。以下是调用完成这个过程的测试类Test的源代码：

>public class Test {

    Object c = null;

    public Test() {
        c = new C();
    }

    public static void main(String args[]) {
        MyClass me = new MyClass();
        me.destroy();
    }

    protected void destroy() {
        if (c != null) {
            c.destroy();
        } else {
            System.out.println("c对象已被释放");
        }
    }
}

    编译执行Test.java：

        > javac Test.java

        > java Test

    下面是这个程序的运行结果：

        创建a对象

        创建b对象

        创建c对象

        释放c对象

        释放b对象

        释放a对象

    我们注意到当在Test类中初始化类C的对象时，其构造器产生了递归调用，并且是由基类开始依次调用、初始化成员对象的，而当调用C类对象的destroy方法时系统同样产生了递归调用，但调用的顺序却与初始化调用的顺序完全相反，释放资源的调用顺序是由子类开始的一次调用其超类的资源释放方法destroy。由此可见我们在设计类时尽可能地避免在类的默认构造器中创建、初始化大量的对象，防止在调用其自类的构造器时造成不必要的内存资源浪费，因为即使我们没有想调用父类的构造器创建大量无用的对象（至少有时候这些对象对我们是没有意义的），但是系统都会自动创建它们，而这些操作与过程对于我们来说是隐含的。