blocks|key|1350111|text|取决于你如何看待它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1350112|或者在Java中没有类似于shared_ptr的东西，因为在Java中不存在值对象(除了int这样的原始类型)，而且RAII也不存在。|offset|length|style|CODE|1350113|Java中的Or...everything就像shared_ptr，因为所有东西都是共享引用，更像是一个引用计数指针。|1350114|entityMap^0|0|D|A|18|3|0|N|A|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|K|$]]

Depends on how you look at it.

Either there's no such thing as anything like <code>shared_ptr</code> in Java because there's no such thing as value objects in Java (except the raw types like <code>int</code>) and RAII doesn't exist there.

Or...everything in Java is just like <code>shared_ptr</code> because everything is a share reference that acts more like a reference counted pointer.

blocks|key|1212023|text|Java中的等价物只是一个普通的对象引用；让GC来完成它的工作。您几乎不应该使用finalize。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1212024|另一种方法是使用PhantomReference+--这允许您在对象停止引用后的某个时刻设置一些处理。|1212025|当对象不再被引用时，你的对象需要做些什么呢？|1212026|entityMap^0|14|8|0|8|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

The equivalent in Java is just a normal object reference; let GC do its work. You should pretty much never use <code>finalize</code>.

An alternative is to use a <code>PhantomReference</code> - this allows you to set up some processing to happen at some point after the object ceases to be referenced.

What is it about your objects that requires some action when it ceases to be referenced?

blocks|key|1212047|text|没有这样的东西--在Java中完成指针或空闲对象的时候，您就不会使用它们了。好吧，你可以这么做，但很有可能你做错了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1212048|如果当所有线程都完成了对对象的处理时，您必须做一些事情，那么您应该自己跟踪它的使用情况，并在完成时进行清理。|1212049|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|$]]

There is no such thing - you don't use pointers or free objects the moment you're done with them in Java. Well, you can do that, but chances are - you'd be doing it wrong.

If you must do something when all threads are finished with handling an object, you should track its use yourself and clean up when you're done.

blocks|key|1212085|text|在Java和+when+an+object+is+collected中没有强制“销毁”对象的通用方法(可能永远不会！)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1212086|人们通常需要担心的唯一资源是文件或流等外部资源--处理这种情况的一般方法--它通过close/AutoClosable使用手动生存期管理(如果使用终结器，则只使用“安全性”)。生存期完全留在调用方中，过早“关闭”资源(例如文件)将使其在其他地方无效。|style|CODE|1212087|这种手动管理可以通过获取/发布池来完成(当所有获取被释放时，“使用计数”变为零，并在基础资源上调用close+)；如果可以预先固定计数，则使用信号量进行更改。|1212088|另一方面，内部管理但不可访问的对象/资源将根据GC的需要被逐出，因此(通常)不需要担心它们的生命周期。|1212089|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/20177580/when-finalize-is-being-executed^0|6|S|0|0|15|I|0|1D|5|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@$A|Y|B|Z|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|10|8|@$A|11|B|12|F|G]]|9|@]|C|$]]|$1|J|3|K|5|6|7|13|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]]]

tldr; There is no general way to force "destruction" of an object in Java - and the <a href="https://stackoverflow.com/questions/20177580/when-finalize-is-being-executed">finalize method is called only when an object is collected</a> (which might be never!)

The only resources that one generally needs to worry about are external resources such as files or stream - the general approach to handle such a case it use manual lifetime management through <code>close/AutoClosable</code> (with the finalizer, if used, only being a "safety"). Lifetime is left entirely in the caller and "closing" a resource (e.g. a File) too early would make it invalid to use elsewhere.

This manual management can be done with an acquire/release pool (when all the acquires are released, the "use count" goes to zero, and <code>close</code> is called on the underlying resource); a variation is with a semaphore, if the count can be pinned in advance.

On the other hand, internally managed but-no-longer-reachable objects/resources will be evicted as needed by the GC and so there is (generally) no need to worry about their lifetime.

blocks|key|1350208|text|您可以创建一个简单的manager对象，它知道如何创建和处理所述资源。在对象上实现同步的checkout()和checkin()方法。签出方法在第一次调用时创建对象，增加引用计数，并返回对对象的引用。签入方法会减少引用计数，当它变为零时，它会处理该对象。然后，您只需使用try/finally模式(类似于锁/解锁)对对象的所有使用范围进行范围：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1350209|Resource+res+=+manager.checkout();
try+{
++//+...+work+with+resource+here+...
}+finally+{
++manager.checkin(res);
}|code-block|syntax|javascript|1350210|注意，使用java+7+AutoCloseable可能会使它变得更干净一些。|1350211|entityMap^0|18|A|1J|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

You can create a simple manager object which knows how to create and dispose of the resource in question. You implement a synchronized <code>checkout()</code> and <code>checkin()</code> method on the object. the checkout method creates the object on the first call, increments a reference count, and returns a reference to the object. the checkin method decrements the reference count, and when it goes to zero, it disposes of the object. then you just scope all usage of the object with a try/finally pattern (similar to lock/unlock):

<pre><code>Resource res = manager.checkout();
try {
 // ... work with resource here ...
} finally {
 manager.checkin(res);
}
</code></pre>

Note, you could probably make this a little cleaner using the java 7 AutoCloseable.

blocks|key|512307|text|做您想做的事情需要付出一定的努力，而且在Java中永远不会觉得很自然，因为对资源的确定性清理对于Java来说是陌生的。不过，从Java+7开始，它已经变得更好了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|512308|解决这一问题的最佳方法是：|512309|在java包装器中添加一个java.util.concurrent.AtomicInteger类型的计数器，初始化为1(谢谢@Jules的支持，现在避免使用synchronized!)。|ordered-list-item|offset|length|style|CODE|512310|添加一个addRef方法，如果计数器为0，该方法将抛出返回this，以便更好地在try-statement中使用。|512311|实现java.lang.AutoCloseable：当计数达到0时，close会减少计数，当计数达到0时释放资源。|512312|添加终结器作为最终安全网:日志失败，以便更早地正确释放资源，并执行最终版本。|512313|将注释添加到每个拥有这样一个引用且不是使用资源进行尝试的变量/参数中，因此您知道如何适当地调用addRef和close。|512314|512315|512316|使用java包装器的try-with-resources-block：|512317|try(resource.AddRef())+{
++++//+Do+your+thing
}|code-block|syntax|javascript|512318|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/441899^0|0|0|D|Y|26|C|1Q|6|0|0|4|6|T|4|14|3|0|2|N|Y|5|0|0|1B|6|1I|5|0|0|0|A|I|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1B|8|@$G|1C|H|1D|I|J]|$G|1E|H|1F|I|J]]|9|@$G|1G|H|1H|1|1I]]|A|$]]|$1|K|3|L|5|F|7|1J|8|@$G|1K|H|1L|I|J]|$G|1M|H|1N|I|J]|$G|1O|H|1P|I|J]]|9|@]|A|$]]|$1|M|3|N|5|F|7|1Q|8|@$G|1R|H|1S|I|J]|$G|1T|H|1U|I|J]]|9|@]|A|$]]|$1|O|3|P|5|F|7|1V|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1W|8|@$G|1X|H|1Y|I|J]|$G|1Z|H|20|I|J]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|21|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|22|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|23|8|@$G|24|H|25|I|J]]|9|@]|A|$]]|$1|W|3|X|5|Y|7|26|8|@]|9|@]|A|$Z|10]]|$1|11|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|12|$13|$5|14|15|16|A|$17|18]]]]

Doing what you want well needs some effort, and will never feel natural in Java, because deterministic cleanup of resources is foreign to Java. It has gotten a bit better since Java 7 though.

The best way to work around it is this:

<ol>
<li>Add a counter of type <code>java.util.concurrent.AtomicInteger</code> to your java wrapper, initialised at 1 (Thanks <a href="https://stackoverflow.com/users/441899">@Jules</a> for that, now avoiding <code>synchronized</code>!).</li>
<li>Add an <code>addRef</code> method, which throws if the counter is 0, returning <code>this</code> for better use in the <code>try</code>-statement.</li>
<li>Implement <code>java.lang.AutoCloseable</code>: <code>close</code> decreases the count when not 0, and releases the resource when the count reaches 0.</li>
<li>Add a finalizer as a final safety-net: Log failure to properly release the resource earlier, and do the final release.</li>
<li>Add a comment to every variable / argument which owns such a reference and is not a try-with-resource, so you know to call <code>addRef</code> and <code>close</code> as appropriate.</li>
</ol>

A <code>try-with-resources</code>-block using the java wrapper:

<pre><code>try(resource.AddRef()) {
 // Do your thing
}
</code></pre>

In a parallel application, threads(32) in a thread group use a shared unmanaged and standalone disposable object.

We have the same thing in our c/c++ app, and there I use <code>shared_ptr&lt;&gt;</code> in order to let object dispose and finalize just after there is no need to the object.

I just tried to apply the same thing in Java, and I faced with <code>finalize()</code> method. But there are some problems, because of GC is so lazy sometimes, the object doesn't even identified as unreachable object for disposing/finalizing, sometimes it is called, but there is no warranty GC lets the object invoke the <code>finalize()</code> completely.

So I just came with another complex solution which I just count down and track the threads are using the object which it doesn't work too, but I know this is not a reliable solution, and I know I will faced with unexpected results.

I'm just wonder if there is something equivalent to <code>shared_ptr&lt;&gt;</code> in java, or is it possible to handle the object via JNI?

Any ideas?

How can I safely and timely dispose a scarce shared resouce in Java?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在并行应用程序中，线程组中的线程(32)使用共享的、非托管的和独立的一次性对象。我们的c/c++应用程序中也有相同的东西，我使用shared_ptr<>来让对象在不需要对象之后进行处理和完成。我只是尝试在Java中应用相同的东西，然后我面对了finalize()方法。但是也存在一些问题，因为GC有时太懒，对象甚至不能被...

问如何安全和及时地使用Java处理稀缺的共享资源？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何安全和及时地使用Java处理稀缺的共享资源？EN