blocks|key|576196|text|总是在最后把事情清理干净。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|576197|不能保证在finalize中进行清理。|576198|然而，经常发现在finalizer中清理这类东西，作为最后一道安全阀，以防finally块向您抛出另一个异常。|576199|依赖终结器的真正问题是，在GC调用终结器之前，其他东西可能需要资源。|576200|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Always clean up things in finally.

Cleaning up in finalize is not guaranteed to occur.

However, it is often found to clean up such things in finalizers as a last-ditch safety valve should a finally block throw another exception on you.

The real problem with relying on finalizers is something else may need the resource before the GC gets around to calling the finalizer.

blocks|key|576455|text|finally块只是一个始终在try块之后执行的代码块，即使有异常也是如此。即它的作用域是局部的|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|576456|finalize()方法是一种在对象被垃圾回收时清理整个对象的方法。|576457|Java+documentation+of+finalize()|576458|finally解决了清理代码块中的资源而不管是否发生异常情况的问题……当您的对象不再被使用时，一旦垃圾收集器确定不再有对该对象的引用，finalize()就是一种清理资源的方法。|576459|简而言之，为了回答您的问题，例如，如果您要关闭的套接字是某个对象的成员，那么您应该在finalize()方法中关闭它们(尽管这不是最优的，例如，因为不能保证GC何时会实际执行操作)。|576460|但是，如果您在一个方法中打开套接字，并在该方法结束时使用它，那么您应该释放finally块中的资源。|576461|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#finalize()^0|0|7|F|3|0|0|A|0|0|W|0|0|0|7|1V|A|0|16|A|0|11|7|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@$9|16|A|17|1|18]]|E|$]]|$1|J|3|K|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|Q|$R|$5|S|T|U|E|$V|W]]]]

The <code>finally</code> block is just a block of code that always executes after a <code>try</code> block, even if there is an exception. i.e. it is local in scope

The <code>finalize()</code> method is an approach for cleaning up the whole object when it is garbage collected.

<a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#finalize()" rel="nofollow noreferrer">Java documentation of finalize()</a>

<code>finally</code> solves the problem of cleaning up resources in a block of code regardless of whether an exceptional condition occurs...
<code>finalize()</code> is a way to clean up resources when your object is no longer being used, once the Garbage Collecter determines there are no more references to that object.

In short, to answer your question, for example, if the sockets you are closing are members of an object you should close them in the <code>finalize()</code> method, (although that's sub-optimal, and just for example, because there is no guarantee when the GC will actually perform the action)

If however you're opening the socket in a method, and are done with it when the method ends you should free the resources in the <code>finally</code> block.

blocks|key|620162|text|如果您的应用程序导致创建大量这样的对象，那么Finalize可能不是一个好主意。这是因为finalize将导致瓶颈，因为对象变得有资格进行垃圾回收。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|620163|有些时候，finalize是唯一的解决方案；但只要有可能，就使用finally|620164|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Finalize is probably a bad idea if your application causes lots of these objects to be created. This is because finalize will cause a bottleneck as the objects become eligible for garbage collection.

There are times when finalize is the only solution; but use finally whenever you can

blocks|key|1876918|text|终于来了。Finalize是不好的，因为它可能永远不会被调用。仅将finalize用作安全网。例如，InputStream应该有一个终结器，以便在应用程序忘记的情况下关闭流。但是，应用程序应该将其关闭。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1876919|如果是我，我也会在终结器中进行清理，并记录执行清理时的情况，然后在应用程序中跟踪忘记正确清理的代码。|1876920|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Finally. Finalize is bad in that it may never get called. Use finalize only as a safety net. For example an InputStream should have a finalize that closes the stream incase the applcicationforgets to. However the application should close it.

If it were me I would do the cleanup in the finalizer as well and log the cases when the cleanup was performed and then track down in the application the code that forgot to properly clean up.

blocks|key|1876942|text|Phantom引用会做你想做的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1876943|只是不要使用finalize。在一些边缘情况下，它可能会有帮助(当一个类被GC'd时打印调试信息是有用的)，但通常不是这样的，JVM合同中甚至没有任何东西说它必须被调用。|1876944|有一种被称为“引用”的非常低调的对象类型。一种是显式地为您认为将使用finalize的东西创建的。|1876945|Phantom+reference对象，在收集器确定其引用对象可能被回收后，将这些对象排入队列。|offset|length|1876946|我突然想到一定有a+description+of+this+on+the+web--所以我将用这个引用替换我刚刚写的所有“如何操作”的东西。|1876947|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ref/PhantomReference.html|1|http://resources.ej-technologies.com/jprofiler/help/doc/indexRedirect.html?http&&&resources.ej-technologies.com/jprofiler/help/doc/helptopics/config/finalizers.html^0|0|0|0|0|H|0|0|8|W|1|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@$H|Z|I|10|1|11]]|A|$]]|$1|J|3|K|5|6|7|12|8|@]|9|@$H|13|I|14|1|15]]|A|$]]|$1|L|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]]]

Phantom References will do what you want.

Just don't use finalize. There are a few edge cases where it may be helpful (printing debug info when a class is GC'd has come in handy), but in general don't. There is nothing in the JVM contract that even says it ever has to be called.

There is a very under-publicized type of object called "References". One is made explicitly for things that you think you would use finalize for.

"<a href="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ref/PhantomReference.html" rel="noreferrer">Phantom reference</a> objects, which are enqueued after the collector determines that their referents may otherwise be reclaimed."

It just occurred to me that there MUST be <a href="http://resources.ej-technologies.com/jprofiler/help/doc/indexRedirect.html?http&amp;&amp;&amp;resources.ej-technologies.com/jprofiler/help/doc/helptopics/config/finalizers.html" rel="noreferrer">a description of this on the web</a>--so I'll replace all the "how-to" stuff I just wrote with this reference.

blocks|key|576515|text|他们没有血缘关系。这就像是在问：“应该在初始化器中还是在普通方法中创建对象？”比如，这取决于你对这些物体做了什么。终结器在对象被销毁时清理对象的状态(也许-这不是你应该依赖的东西)，而finally块在try块之后执行代码。没有任何常见的情况，你可以选择一个或另一个，因为他们做不同的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|576516|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

They're not related. This is like asking, "Should you create objects in an initializer or in normal methods?" Like, it depends on what you're doing with the objects. A finalizer cleans up an object's state while it's destroyed (maybe — it's not something you should rely on), while a finally block executes code after a try block. There isn't any common situation where you'd be able to choose one or the other since they do different things.

blocks|key|576531|text|问题中的代码存在许多问题，包括：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|576532|576533|最大的问题是:看起来你正在尝试关闭一个套接字。即使你没有正确地关闭它，它也会在它自己的finaliser中关闭。添加另一个终结器并不会使其更加封闭。添加第一个终结器抛出的异常将阻止其他终结器执行(碰巧的是，这在本例中并不重要，因为Socket).|unordered-list-item|offset|length|style|CODE|576534|If的特殊行为确实重写了finalize，让它抛出Throwable+(并添加@|576535|)。从技术上讲，你还应该在finaliser块中调用超级函数。|576536|当涉及终结器时，Java是非常奇怪的(以前的代码执行并不一定发生-在终结器执行之前)。我会解释这个问题，但你需要知道的是，你需要远离终结者。|576537|576538|所以:对于这些事情，一定要使用finally。finalize是非常专业的(+PhantomReference可能更好，表面上更复杂)。|576539|entityMap^0|0|0|37|6|0|C|8|P|9|0|0|0|0|F|7|N|8|13|G|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|W|8|@$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|Z|8|@$F|10|G|11|H|I]|$F|12|G|13|H|I]]|9|@]|A|$]]|$1|L|3|M|5|E|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|E|7|15|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|17|8|@$F|18|G|19|H|I]|$F|1A|G|1B|H|I]|$F|1C|G|1D|H|I]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|T|$]]

There are a number of problems with the code in the question, including:

<ul>
<li>The big problem: It looks like you are trying to close a socket. Even if you don't close it properly, it will close in its own finaliser. Adding another finaliser doesn't make it any more closed.</li>
<li>An exception thrown by the first <code>close</code> will prevent the others from executing (as it happens, this doesn't matter in this example because of the peculiar behaviour of <code>Socket</code>).</li>
<li>If you do override <code>finalize</code>, leave it throwing <code>Throwable</code> (and add @Override). Technically you should also call the super in a finally block.</li>
<li>The Java Memory Model is mighty strange when it comes to finalisers (previous execution of code does not necessarily happen-before the execution of the finaliser). I would explain the problem, but what you need to know is that you need to stay away from finalisers.</li>
</ul>

So: Always use <code>finally</code> for these things. <code>finalize</code> is extremely specialised (and <code>PhantomReference</code> are probably better is superficially more complicated).

blocks|key|576358|text|如果您正在寻找finalize()的替代品，那么正确的问题应该是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|576359|当有finalize()时，|576360|为什么要使用显式的close()方法，例如，java.io.*和许多其他类中的所有流和写入器/读取器类|unordered-list-item|576361|576362|其他答案清楚地表明，finalize()的缺点是您没有办法强制它运行，任何可能使用您的代码的人也是如此。|576363|当然，调用close()方法(最好在finally块或close()方法本身中完成)必须由作者记录下来，然后记住要由使用代码的人调用。但有很多例子(不仅仅是java.io.*)强加了这种方法，并且它是有效的。|576364|顺便说一句：close()只是一个约定。|576365|entityMap^0|7|A|0|2|A|0|9|7|0|0|A|A|0|5|7|I|7|R|7|26|9|0|6|7|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|12|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|S|$]]

If you are looking for alternatives to <code>finalize()</code> the proper question would be:

<ul>
<li>Why use an explicit <code>close()</code> method like, for example, all the stream and writer/reader classes in java.io.* and many others - when there is <code>finalize()</code>?</li>
</ul>

The other answers make it clear that the disadvantage of <code>finalize()</code> is that you have no way to force it to run, and neither do any who might use your code.

Of course, calling a <code>close()</code> methode (best done in a <code>finally</code> block or in a <code>close()</code> method itself) has to be documented by the author and then remembered to be called by the ones using the code. But there are lots of examples (not only <code>java.io.*</code>) where this is imposed and it works.

BTW: <code>close()</code> is merely a convention.

blocks|key|620395|text|Joshua+Bloch在他的书Effective+Java+(2nd+Edition)中做了一个非常明确的推荐。从第2章Item+7:+Avoid+finalizers复制|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|620396|620397|+终结器是不可预测的，通常是危险的，而且通常是不必要的。使用它们可能会导致行为不稳定、性能低下和可移植性问题。终结器有一些有效的用法，我们将在本文后面介绍，但根据经验，您应该避免终结器。|blockquote|style|BOLD|620398|620399|620400|请阅读参考，找出原因。|620401|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0321356683|1|http://my.safaribooksonline.com/book/programming/java/9780137150021/creating-and-destroying-objects/ch02lev1sec7^0|G|S|0|1P|O|1|0|0|1|R|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]|$A|11|B|12|1|13]]|C|$]]|$1|D|3|-4|5|6|7|14|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|15|8|@$A|16|B|17|H|I]]|9|@]|C|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|19|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1A|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]|V|$5|Q|R|S|C|$T|W]]]]

Joshua Bloch makes a very clear recommendation in his book <a href="https://rads.stackoverflow.com/amzn/click/com/0321356683" rel="nofollow noreferrer" rel="nofollow noreferrer">Effective Java (2nd Edition)</a>. Copied from chapter 2 <a href="http://my.safaribooksonline.com/book/programming/java/9780137150021/creating-and-destroying-objects/ch02lev1sec7" rel="nofollow noreferrer">Item 7: Avoid finalizers</a>:

<blockquote>
 Finalizers are unpredictable, often dangerous, and generally unnecessary. Their use can cause erratic behavior, poor performance, and portability problems. Finalizers have a few valid uses, which we’ll cover later in this item, but as a rule of thumb, you should avoid finalizers.
</blockquote>

Please read the reference to find out why.

I had the general view that clean up of resources is done in the <code>finally</code> block, 
recently I found this particular code snippet in a class and it was overriding the <code>Object</code> class' <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html#finalize%28%29" rel="nofollow noreferrer"><code>finalize()</code></a> method.

<pre><code>protected void finalize() { 
 try {
 In.close(); 
 Out.close();
 socket.close();
 }
 catch (Exception e) {
 //logger code here
 }
}
</code></pre>

Is this a good idea? What are the pros and cons of <code>finalize()</code> over <code>finally</code>?

Clean up code in finalize() or finally()?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我一般认为清理资源是在finally块中完成的，最近，我在一个类中发现了这个特殊的代码片段，它覆盖了Object类的方法。protected void finalize() {      try {        In.close();         Out.close();        socket.close(...

问清理finalize()或finally()中的代码？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问清理finalize()或finally()中的代码？EN