Java中的对象终结机制（finalize()方法）详解

一、finalize()方法的基本概念
finalize()是Object类中定义的一个protected方法，当垃圾回收器确定不存在对该对象的更多引用时，由垃圾回收器自动调用。其方法签名如下：

protected void finalize() throws Throwable

二、finalize()方法的执行时机

1. 垃圾回收条件：当对象变成垃圾（不再被任何引用指向）时，它有资格被垃圾回收
2. 调用时机：在垃圾回收器真正回收对象内存之前，会先调用其finalize()方法
3. 执行保证：JVM不保证finalize()方法会被立即执行，也不保证其执行顺序

三、finalize()方法的执行流程

对象不可达 → 进入回收队列 → 执行finalize() → 真正回收内存

详细步骤：

1. 垃圾回收器发现对象没有引用指向（不可达）
2. 判断对象是否重写了finalize()方法且尚未被调用过
3. 如果是，将对象放入F-Queue队列中
4. 由低优先级的Finalizer线程异步调用finalize()方法
5. 执行完毕后，在下一轮GC时真正回收对象内存

四、finalize()方法的特点与限制

1. 不确定性：无法预测finalize()何时执行，甚至可能根本不执行
2. 自动调用：只能由垃圾回收器调用，不应手动调用
3. 异常处理：finalize()中的异常不会被传播，会被静默忽略
4. 性能影响：使用finalize()会显著增加垃圾回收的开销

五、finalize()方法的实际示例

public class ResourceCleanupExample {
    private String resourceName;
    
    public ResourceCleanupExample(String name) {
        this.resourceName = name;
        System.out.println("创建资源: " + resourceName);
    }
    
    @Override
    protected void finalize() throws Throwable {
        try {
            System.out.println("正在清理资源: " + resourceName);
            // 模拟资源清理操作
        } finally {
            super.finalize(); // 调用父类的finalize()
        }
    }
    
    public static void main(String[] args) {
        new ResourceCleanupExample("测试资源");
        
        // 触发GC（只是建议，不保证立即执行）
        System.gc();
        
        // 给Finalizer线程时间执行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

六、finalize()方法的复活机制
对象可以在finalize()方法中"复活"自己，避免被回收：

public class ResurrectionExample {
    private static ResurrectionExample savedInstance;
    
    @Override
    protected void finalize() throws Throwable {
        System.out.println("finalize()被调用");
        savedInstance = this; // 复活对象
    }
    
    public static void main(String[] args) {
        ResurrectionExample obj = new ResurrectionExample();
        obj = null; // 使对象不可达
        
        System.gc();
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        
        if (savedInstance != null) {
            System.out.println("对象被复活");
        }
    }
}

七、finalize()的替代方案
由于finalize()的诸多问题，推荐使用以下替代方案：

1. try-with-resources（Java 7+）：

public class Resource implements AutoCloseable {
    @Override
    public void close() {
        System.out.println("资源被明确关闭");
    }
}

// 使用方式
try (Resource res = new Resource()) {
    // 使用资源
} // 自动调用close()

2. PhantomReference（虚引用）：

public class PhantomReferenceCleanup {
    public static void main(String[] args) {
        Object obj = new Object();
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        PhantomReference<Object> phantomRef = 
            new PhantomReference<>(obj, queue);
        
        obj = null; // 使对象成为垃圾
        
        // 监控队列，在对象被回收后执行清理
        new Thread(() -> {
            try {
                Reference<?> ref = queue.remove();
                System.out.println("对象已被回收，执行清理");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

八、finalize()的最佳实践

1. 避免使用finalize()进行重要的资源清理
2. 如果必须使用，一定要调用super.finalize()
3. 考虑使用Cleaner类（Java 9+）作为更安全的替代方案
4. 优先使用try-with-resources进行资源管理

九、finalize()在JDK中的演进

• Java 9：将Object.finalize()标记为deprecated
• Java 18：正式移除finalize()方法
• 替代方案：推荐使用java.lang.ref.Cleaner进行资源清理

finalize()机制是Java早期设计的产物，现代Java开发中应避免使用，转而采用更可靠、更可预测的资源管理方式。