对象的 finalization 机制

淡淡的烟草味﹌ 2022-08-31 04:41 69阅读 0赞

# 一 点睛 #

Java 语言提供了对象终止（finalization）机制来允许开发人员提供对象被销毁之前的自定义处理逻辑。

当垃圾回收器发现没有引用指向一个对象，即：垃圾回收此对象之前，总会先调用这个对象的 finalize() 方法。

finalize() 方法允许在子类中被重写，用于在对象被回收时进行资源释放。通常在这个方法中进行一些资源释放和清理的工作，比如关闭文件、套接字和数据库连接等。

从功能上来说，finalize() 方法与 c++ 中的析构函数比较相似，但是 Java 采用的是基于垃圾回收器的自动内存管理机制，所以 finalize() 方法在本质上不同于C++中的析构函数。

# 二 注意 #

永远不要主动调用某个对象的 finalize()方法，应该交给垃圾回收机制调用。理由包括下面三点：

*  在 finalize() 时可能会导致对象复活。
 *  finalize() 方法的执行时间是没有保障的，它完全由 GC线程决定，极端情况下，若不发生 GC，则 finalize() 方法将没有执行机会。因为优先级比较低，即使主动调用该方法，也不会因此就直接进行回收。
 *  一个糟糕的 finalize() 会严重影响 GC 的性能。

# 三 对象是生存还是死亡？ #

由于 finalize() 方法的存在，虚拟机中的对象一般处于三种可能的状态。

如果从所有的根节点都无法访问到某个对象，说明对象己经不再使用了。一般来说，此对象需要被回收。但事实上，也并非是“非死不可”的，这时候它们暂时处于“缓刑”阶段。一个无法触及的对象有可能在某一个条件下“复活”自己，如果这样，那么对它的回收就是不合理的，为此，定义虚拟机中的对象可能的三种状态。

可触及的：从根节点开始，可以到达这个对象。

可复活的：对象的所有引用都被释放，但是对象有可能在 finalize() 中复活。

不可触及的：对象的 finalize() 被调用，并且没有复活，那么就会进入不可触及状态。不可触及的对象不可能被复活，因为 finalize() 只会被调用一次。

以上3种状态中，是由于 finalize() 方法的存在而进行的区分。只有在对象不可触及时才可以被回收。

# 四 具体过程 #

判定一个对象 objA 是否可回收，至少要经历两次标记过程：

1 如果对象 objA 到 GC Roots 没有引用链，则进行第一次标记。

2 进行筛选，判断此对象是否有必要执行 finalize() 方法。

a 如果对象 objA 没有重写 finalize() 方法，或者 finalize() 方法已经被虚拟机调用过，则虚拟机视为“没有必要执行”，objA 被判定为不可触及的。

b 如果对象 objA 重写了 finalize() 方法，且还未执行过，那么 objA 会被插入到 F-Queue 队列中，由一个虚拟机自动创建的、低优先级的 Finalizer 线程触发其 finalize() 方法执行。

c finalize() 方法是对象逃脱死亡的最后机会，稍后 GC 会对 F-Queue 队列中的对象进行第二次标记。如果 objA 在 finalize() 方法中与引用链上的任何一个对象建立了联系，那么在第二次标记时，objA 会被移出“即将回收”集合。之后，对象会再次出现没有引用存在的情况。在这个情况下，finalize() 方法不会被再次调用，对象会直接变成不可触及的状态，也就是说，一个对象的 finalize() 方法只会被调用一次。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70][]

上图就是的 Finalizer 线程。

# 五 实战 #

## 1 说明 ##

重写 finalize()方法，然后在方法的内部，将对象复活

## 2 代码 ##

/**
    * 测试 Object 类中 finalize() 方法，即对象的 finalization 机制。
    */
    public class CanReliveObj {
        public static CanReliveObj obj; // 类变量，属于 GC Root
        // 此方法只能被调用一次
        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("调用当前类重写的finalize()方法");
            obj = this; // 当前待回收的对象在 finalize() 方法中与引用链上的一个对象 obj 建立了联系，对象复活了
        }
    
        public static void main(String[] args) {
            try {
                obj = new CanReliveObj();
                // 对象第一次成功拯救自己
                obj = null;
                System.gc(); // 调用垃圾回收器
                System.out.println("第1次 gc");
                // 因为 Finalizer 线程优先级很低，暂停 2 秒，以等待它
                Thread.sleep(2000);
                if (obj == null) {
                    System.out.println("obj is dead");
                } else {
                    System.out.println("obj is still alive");
                }
                System.out.println("第2次 gc");
                // 下面这段代码与上面的完全相同，但是这次自救却失败了，因为一个对象的 finalize() 方法只会被调用一次
                obj = null;
                System.gc();
                // 因为 Finalizer 线程优先级很低，暂停2秒，以等待它
                Thread.sleep(2000);
                if (obj == null) {
                    System.out.println("obj is dead");
                } else {
                    System.out.println("obj is still alive");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

## 3 最后运行结果 ##

> \-----------------第一次gc操作------------
> 
> 调用当前类重写的finalize()方法
> 
> obj is still alive
> 
> \-----------------第二次gc操作------------
> 
> obj is dead

## 4 图解 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1][]

## 5 分析 ##

在进行第一次清除的时候，我们会执行 finalize方法，对象进行了一次自救操作，但是因为 finalize() 方法只会被调用一次，因此第二次该对象将会被垃圾清除。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70]: /images/20220829/17369762729c407ca4aae52c6d0b1070.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1]: /images/20220829/0b146ab6e68841d997a3f7c9ce3f5533.png