使用Java的ReferenceQueue

问题描述

如果 SoftReference 和 WeakReference 真的只在作为实例变量创建时才有帮助？在方法范围中使用它们有什么好处？

另一大部分是 ReferenceQueue 。除了能够跟踪哪些引用被确定为垃圾之外，还可以使用 Reference.enqueue（）强制注册一个垃圾收集对象

例如，是否值得创建一个方法，该方法需要占用大量内存资源（由强引用保存）并创建引用才能将它们排入队列？

  Object bigObject; 
 public void dispose（）{
 ReferenceQueue< Object> queue = new ReferenceQueue< Object>（）; 
 WeakReference< Object> ref = new WeakReference< Object>（bigObject，queue）; 
 bigObject = null; 
 ref.enqueue（）; 
 
 
 
 
 
 
（想象一下，在这种情况下，Object表示一个对象类型，它使用了很多内存......像 BufferedImage 或其他）
 
 
这是否有任何实际效果？或者这只是代码的浪费？
解决方案
参考队列的一个常见习惯是例如子类 WeakReference 来附加清理信息所需的信息，然后轮询 ReferenceQueue 来完成清理任务。 / p> 
 
 
  ReferenceQueue< Foo> fooQueue = new ReferenceQueue< Foo>（）; 
 
 class ReferenceWithCleanup extends WeakReference< Foo> {
吧台; 
 ReferenceWithCleanup（Foo foo，酒吧栏）{
 super（foo，fooQueue）; 
 this.bar = bar; 
} 
 public void cleanUp（）{
 bar.cleanUp（）; 
 
 
 
公共线程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）; 
 ... //从现在开始，一旦你释放所有对foo的非弱引用，
 //然后在未来的某个不确定点，bar.cleanUp（）将会
 / /被运行。你可以通过调用ref.enqueue（）来强制它。 
} 
  
例如，Guava的 CacheBuilder  weakKeys 时，执行code> 这种方法。
 
Do SoftReference and WeakReference really only help when created as instance variables? Is there any benefit to using them in method scope?
The other big part is ReferenceQueue. Besides being able to track which references are determined garbage, can Reference.enqueue() 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?
Object bigObject;
public void dispose() {
    ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
    WeakReference<Object> ref = new WeakReference<Object>(bigObject, queue);
    bigObject = null;
    ref.enqueue();
}
(Imagine that Object in this case represents an object type that uses a lot of memory... like BufferedImage or something)
Does this have any realistic effect? Or is this just a waste of code?
 解决方案 
One common idiom with reference queues is to e.g. subclass WeakReference to attach information that's needed to clean up things, and then to poll a ReferenceQueue to get cleanup tasks.
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().
}
For example, the internals of Guava's CacheBuilder implementation when weakKeys are selected uses this approach.
                        
这篇关于使用Java的ReferenceQueue的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！