我同意大部分答案。

你不应该完全依赖finalize或ShutdownHook

完成

The JVM does not guarantee when this finalize() method will be invoked. finalize() gets called only once by GC thread. If an object revives itself from finalizing method, then finalize will not be called again. In your application, you may have some live objects, on which garbage collection is never invoked. Any Exception that is thrown by the finalizing method is ignored by the GC thread System.runFinalization(true) and Runtime.getRuntime().runFinalization(true) methods increase the probability of invoking finalize() method but now these two methods have been deprecated. These methods are very dangerous due to lack of thread safety and possible deadlock creation.

shutdownHooks

public void addShutdownHook(Thread hook)

注册一个新的虚拟机关闭钩子。

Java虚拟机在响应两种事件时关闭:

The program exits normally, when the last non-daemon thread exits or when the exit (equivalently, System.exit) method is invoked, or The virtual machine is terminated in response to a user interrupt, such as typing ^C, or a system-wide event, such as user logoff or system shutdown. A shutdown hook is simply an initialized but non-started thread. When the virtual machine begins its shutdown sequence it will start all registered shutdown hooks in some unspecified order and let them run concurrently. When all the hooks have finished it will then run all uninvoked finalizers if finalization-on-exit has been enabled. Finally, the virtual machine will halt. Note that daemon threads will continue to run during the shutdown sequence, as will non-daemon threads if the shutdown was initiated by invoking the exit method. Shutdown hooks should also finish their work quickly. When a program invokes exit the expectation is that the virtual machine will promptly shut down and exit. But even Oracle documentation quoted that

在极少数情况下，虚拟机可能会中止，即停止运行而不完全关闭

这发生在虚拟机从外部终止时，例如在Unix上使用SIGKILL信号或在Microsoft Windows上使用TerminateProcess调用。如果本机方法出错，虚拟机也可能中止，例如破坏内部数据结构或试图访问不存在的内存。如果虚拟机中止，则不能保证是否会运行任何shutdown钩子。

结论:合理使用try{} catch{} finally{}块，释放finally(}块中的关键资源。在finally{}块中释放资源时，捕获Exception和Throwable。

在Lombok中有一个@Cleanup注释，它与c++的析构函数非常相似:

@Cleanup
ResourceClass resource = new ResourceClass();

在处理它时(在编译时)，Lombok插入适当的try-finally块，以便在执行离开变量的作用域时调用resource.close()。你也可以显式地指定另一个方法来释放资源，例如resource.dispose():

@Cleanup("dispose")
ResourceClass resource = new ResourceClass();

首先，请注意，由于Java是垃圾收集的，因此很少需要对对象销毁做任何事情。首先是因为你通常没有任何托管资源可以释放，其次是因为你无法预测它何时或是否会发生，所以当你需要“一旦没有人再使用我的对象”就发生的事情是不合适的。

你可以使用java.lang.ref.PhantomReference在一个对象被销毁后得到通知(实际上，说它已经被销毁可能有点不准确，但如果对它的幻影引用处于队列中，那么它就不再是可恢复的，这通常是一样的)。常见的用法是:

Separate out the resource(s) in your class that need to be destructed into another helper object (note that if all you're doing is closing a connection, which is a common case, you don't need to write a new class: the connection to be closed would be the "helper object" in that case). When you create your main object, create also a PhantomReference to it. Either have this refer to the new helper object, or set up a map from PhantomReference objects to their corresponding helper objects. After the main object is collected, the PhantomReference is queued (or rather it may be queued - like finalizers there is no guarantee it ever will be, for example if the VM exits then it won't wait). Make sure you're processing its queue (either in a special thread or from time to time). Because of the hard reference to the helper object, the helper object has not yet been collected. So do whatever cleanup you like on the helper object, then discard the PhantomReference and the helper will eventually be collected too.

还有finalize()，它看起来像析构函数，但行为并不像析构函数。这通常不是一个好的选择。

我刚刚扫描的所有答案的缺失形式是终结器更安全的替代品。关于使用try-with-resources和避免终结器，所有其他答案都是正确的，因为它们不可靠，现在已弃用……

但是他们没有提到清洁工。Java 9中添加了清洁器，以一种比终结器更好的方式显式地处理清理工作。

https://docs.oracle.com/javase/9/docs/api/java/lang/ref/Cleaner.html

Java没有任何析构函数。在Java中，它背后的主要原因是垃圾收集器总是被动地在后台工作，所有对象都在堆内存中创建，这是GC工作的地方。在c++中，我们必须显式调用delete函数，因为没有垃圾收集器之类的东西。

不,. lang。Object#finalize是最接近的。

但是，不保证何时(以及是否)调用它。 看到:java.lang.Runtime # runFinalizersOnExit(布尔)