blocks|key|177381|text|如果一个对象只有WeakReference(或者没有任何引用！)因此，每当Java需要在内存中腾出更多空间时，都可以对其进行垃圾回收。所以，只要你想让一个对象留在内存中，但又不那么需要它，你就可以使用Java+(例如，如果WeakReference需要对它进行垃圾回收，没问题，你可以以某种方式把它取回来，同时Java有更好的性能)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|177382|将WeakReference排入队列允许您迭代ReferenceQueue并确定哪些引用已被垃圾收集，哪些未被垃圾收集。这就是全部-所以只有当你需要知道这一点时才去做。|177383|阅读更多：http://weblogs.java.net/blog/2006/05/04/understanding-weak-references|177384|entityMap|0|LINK|mutability|MUTABLE|url|http://weblogs.java.net/blog/2006/05/04/understanding-weak-references^0|8|D|33|D|0|1|D|N|E|0|5|1X|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|J|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

If an object has only <code>WeakReference</code>s (or no references whatsoever!) towards it, it can be garbage collected whenever Java needs to make more room in memory. So, you use <code>WeakReference</code>s whenever you want an object to remain in memory, but you don't need it to remain THAT badly (e.g. if Java needs to garbage collect it, no problem, you can get it back somehow and in the mean time Java has better performance)

Enqueuing a <code>WeakReference</code> allows you to iterate the <code>ReferenceQueue</code> and determine which references have been garbage collected and which have not. That's all - so only do it if you need to know this.

Read more:
<a href="http://weblogs.java.net/blog/2006/05/04/understanding-weak-references" rel="nofollow noreferrer">http://weblogs.java.net/blog/2006/05/04/understanding-weak-references</a>

blocks|key|395256|text|引用队列的一个常见习惯用法是，例如，子类WeakReference附加清理任务所需的信息，然后轮询ReferenceQueue以获取清理任务。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|395257|ReferenceQueue<Foo>+fooQueue+=+new+ReferenceQueue<Foo>();

class+ReferenceWithCleanup+extends+WeakReference<Foo>+{
++Bar+bar;
++ReferenceWithCleanup(Foo+foo,+Bar+bar)+{
++++super(foo,+fooQueue);
++++this.bar+=+bar;
++}
++public+void+cleanUp()+{
++++bar.cleanUp();
++}
}

public+Thread+cleanupThread+=+new+Thread()+{
++public+void+run()+{
++++while(true)+{
++++++ReferenceWithCleanup+ref+=+(ReferenceWithCleanup)fooQueue.remove();
++++++ref.cleanUp();
++++}
++}
}

public+void+doStuff()+{
++cleanupThread.start();
++Foo+foo+=+new+Foo();
++Bar+bar+=+new+Bar();
++ReferenceWithCleanup+ref+=+new+ReferenceWithCleanup(foo,+bar);
++...+//+From+now+on,+once+you+release+all+non-weak+references+to+foo,
++++++//+then+at+some+indeterminate+point+in+the+future,+bar.cleanUp()+will
++++++//+be+run.+You+can+force+it+by+calling+ref.enqueue().
}|code-block|syntax|javascript|395258|例如，当weakKeys被选择uses这种方法时，Guava的CacheBuilder实现的内部。|395259|entityMap|0|LINK|mutability|MUTABLE|url|http://google.github.io/guava/releases/19.0/api/docs/com/google/common/cache/CacheBuilder.html#weakKeys()^0|K|D|1D|E|0|0|4|8|V|C|F|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|M|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

One common idiom with reference queues is to e.g. subclass <code>WeakReference</code> to attach information that's needed to clean up things, and then to poll a <code>ReferenceQueue</code> to get cleanup tasks.

<pre><code>ReferenceQueue&lt;Foo&gt; fooQueue = new ReferenceQueue&lt;Foo&gt;();

class ReferenceWithCleanup extends WeakReference&lt;Foo&gt; {
 Bar bar;
 ReferenceWithCleanup(Foo foo, Bar bar) {
 super(foo, fooQueue);
 this.bar = bar;
 }
 public void cleanUp() {
 bar.cleanUp();
 }
}

public Thread cleanupThread = new Thread() {
 public void run() {
 while(true) {
 ReferenceWithCleanup ref = (ReferenceWithCleanup)fooQueue.remove();
 ref.cleanUp();
 }
 }
}

public void doStuff() {
 cleanupThread.start();
 Foo foo = new Foo();
 Bar bar = new Bar();
 ReferenceWithCleanup ref = new ReferenceWithCleanup(foo, bar);
 ... // From now on, once you release all non-weak references to foo,
 // then at some indeterminate point in the future, bar.cleanUp() will
 // be run. You can force it by calling ref.enqueue().
}
</code></pre>

For example, the internals of Guava's <code>CacheBuilder</code> implementation when <code>weakKeys</code> are selected <a href="http://google.github.io/guava/releases/19.0/api/docs/com/google/common/cache/CacheBuilder.html#weakKeys()" rel="noreferrer">uses</a> this approach.

blocks|key|177450|text|一种常见的做法是创建软引用的映射。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|177451|Map<String,+SoftReference<BigThing>>+cache+=+new+HashMap<>();
Set<String>+thingsIAmCurrentlyGetting+=+new+HashSet<String>();
Object+mutex+=+new+Object();

BigThing+getThing(String+key)+{
++synchronized(mutex)+{
++++while(thingsIAmCurrentlyGetting.contains(key))+{
++++++mutex.wait();
++++}
++++SoftReference<BigThing>+ref+=+cache.get(key);
++++BigThing+bigThing+=+ref+==+null+?+null+:+ref.get();
++++if(bigThing+!=+null)+return+bigThing;
++++thingsIAmCurrentlyGetting.add(key);
++}

++BigThing+bigThing+=+getBigThing(key);+//+this+may+take+a+while+to+run.

++synchronized(mutex)+{
++++cache.put(key,+bigThing);
++++thingsIAmCurrentlyGetting.remove(key);
++++mutex.notifyAll();
++}

++return+bigThing;
}|code-block|syntax|javascript|177452|我在这里展示了我的老校友-新的java包可能有更好的方法来做到这一点。|177453|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

One common thing to do is to create maps of soft references.

<pre><code>Map&lt;String, SoftReference&lt;BigThing&gt;&gt; cache = new HashMap&lt;&gt;();
Set&lt;String&gt; thingsIAmCurrentlyGetting = new HashSet&lt;String&gt;();
Object mutex = new Object();

BigThing getThing(String key) {
 synchronized(mutex) {
 while(thingsIAmCurrentlyGetting.contains(key)) {
 mutex.wait();
 }
 SoftReference&lt;BigThing&gt; ref = cache.get(key);
 BigThing bigThing = ref == null ? null : ref.get();
 if(bigThing != null) return bigThing;
 thingsIAmCurrentlyGetting.add(key);
 }

 BigThing bigThing = getBigThing(key); // this may take a while to run.

 synchronized(mutex) {
 cache.put(key, bigThing);
 thingsIAmCurrentlyGetting.remove(key);
 mutex.notifyAll();
 }

 return bigThing;
}
</code></pre>

I'm showing my old school here - the new java packages probably have much neater ways to do this.

blocks|key|177481|text|不确定这里的问题是什么，但是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|177482|1)软引用尝试保留引用，直到jvm真正需要内存。非常适合缓存，尤其是LRU缓存。看看Guava中的许多示例。|177483|2)弱ref根本不会试图阻止gc释放对象。如果您想知道该对象是否仍在某处使用，则可以使用它们。例如，它们用于存储有关线程和类的信息，因此当线程或类不再使用时，我们可以丢弃与之相关的metainfo。|177484|3)+phantom+ref类似于弱对象，但不能让你引用实际对象。通过这种方式，您可以确保传递phantom不能恢复实际的对象(这是弱ref的风险)。另外，幻影ref会阻塞要收集的对象，直到您清除ref为止。|177485|ReferenceQueue:你不能把东西放在里面。gc会为你做的。它们允许您知道某些引用何时发布，而不必逐个检查它们。|177486|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Not sure what is the question here but:

1) soft ref try to keep the reference until jvm really really needs the memory. Great for caches, esp LRU ones. Look at many examples in Guava.

2) weak ref don't try to prevent gc to free the object at all. They are used if you want to know if that object is still used somewhere. For example they are used to store info about threads and classes, so that when the thread or the class is not used anymore we can discard the metainfo related to that.

3) phantom ref are like weak but without letting you reference the actual object. In this way you can be sure that passing the phantom around cannot resume the actual object (this is a risk with weak ref). Also phantom ref are blocking the object to be collected until you clear the ref.

ReferenceQueue: you don't enque stuff in there. gc will do for you. They allows you to know when some references get released, without having to check them one by one.

Do <code>SoftReference</code> and <code>WeakReference</code> really only help when created as instance variables? Is there any benefit to using them in method scope?

The other big part is <code>ReferenceQueue</code>. Besides being able to track which references are determined garbage, can <code>Reference.enqueue()</code> be used to forcibly register an object for garbage collection?

For example, would it be worth to create a method that takes some heavy memory resources (held by strong references) in an object and creating References to enqueue them?

<pre><code>Object bigObject;
public void dispose() {
 ReferenceQueue&lt;Object&gt; queue = new ReferenceQueue&lt;Object&gt;();
 WeakReference&lt;Object&gt; ref = new WeakReference&lt;Object&gt;(bigObject, queue);
 bigObject = null;
 ref.enqueue();
}
</code></pre>

(Imagine that Object in this case represents an object type that uses a lot of memory... like <code>BufferedImage</code> or something)

Does this have any realistic effect? Or is this just a waste of code?

Using Java's ReferenceQueue

Java

SoftReference和WeakReference真的只在作为实例变量创建时才有帮助吗？在方法作用域中使用它们有什么好处吗？另一个重要的部分是ReferenceQueue。除了能够跟踪哪些引用被确定为垃圾之外，是否可以使用Reference.enqueue()强制注册对象以进行垃圾收集？例如，是否值得创建一个在对象...

问使用Java的ReferenceQueue
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Java的ReferenceQueueEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Java的ReferenceQueue
EN