WeakReference 与 PhantomReference 加入ReferenceQueue时机的疑惑

阅读了 Guidelines for using the Java 2 reference classes  与 Understanding Weak References  之后，发现两篇文章关于 WeakReference 和 PhantomReference 何时被加入到 ReferenceQueue有些出入。也就是说到底是在引用的对象没有强引用时还是在引用的对象真正被回收时。于是写了如下程序进行验证：

package mypackage;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;

class TestObj {
	
	//定义三种Reference用于保存指向本对象的Reference，从而在finalize中检验他们的get()值
	private SoftReference sr = null;
	private WeakReference wr = null;
	private PhantomReference pr = null;
	
	//定义ReferenceQueue用于在finalize中检验指向本对象的reference是否被加入了这个Queue
	private static ReferenceQueue rq = null;

	public static void setQueue(ReferenceQueue referenceQueue) {
		rq = referenceQueue;
	}

	public void setSr(SoftReference sr) {
		this.sr = sr;
	}

	public void setWr(WeakReference wr) {
		this.wr = wr;
	}

	public void setPr(PhantomReference pr) {
		this.pr = pr;
	}

	public void finalize() {
		
		//检验指向本对象的Reference的get()值
		if (null != sr)
			System.out.println("Soft Reference refers to " + sr.get()
					+ " in finalize().");
		if (null != wr)
			System.out.println("Weak Reference refers to " + wr.get()
					+ " in finalize().");
		if (null != pr)
			System.out.println("Phantom Reference refers to " + pr.get()
					+ " in finalize().");

		
		//验证是不是在对象finalize()的时候他的soft reference已经被加入至Queue中
		Reference r = rq.poll();

		while (null != r) {
			System.out.println(r.getClass().getName()
					+ " is added in the queue in finalize().");
			r = rq.poll();
		}

	}
}

public class Test {

	public static void main(String[] args) {
		{
           //用于传给三种Reference的强引用
			TestObj softObj = new TestObj();
			TestObj weakObj = new TestObj();
			TestObj phantomObj = new TestObj();

			ReferenceQueue rq = new ReferenceQueue();

		   //三种Reference指向三个不同的对象
			SoftReference sr = new SoftReference(softObj, rq);
			WeakReference wr = new WeakReference(weakObj, rq);
			PhantomReference pr = new PhantomReference(phantomObj, rq);
           
		   //将Reference传回给对应的对象
			softObj.setSr(sr);
			weakObj.setWr(wr);
			phantomObj.setPr(pr);
			
			//将ReferenceQueue传回给对象类
			TestObj.setQueue(rq);
            
			//删除强引用
			softObj = null;
			weakObj = null;
			phantomObj = null;
			System.gc();
			
			Reference r = null;

			// 为了确保对象被GC回收
			//******************************************
			
			while (null == r)
			{
				System.gc();
				r = rq.poll();
			}
			//******************************************

			while (null != r) {
				System.out.println(r.getClass().getName()
						+ " is added in the queue out of finalize().");
				r = rq.poll();
			}

		}

	}

}

 

但发现程序输出的结果是：

 

Phantom Reference refers to null in finalize().
Weak Reference refers to null in finalize().
Soft Reference refers to null in finalize().

 

这就有点让我纳闷了，到底是这些Reference没被加入Queue中呢还是内存中的对象没了被真正回收呢？ 以/********包围起来的语句是我后来加上去的，是为了确保对象确实被回收，但发现这样的话程序就死循环了。

 

请高手解疑：）

评论

5 楼 leonzhx 2010-10-01  

JDK 1.6的ReferenceQueue.enqueue

boolean enqueue (Reference reference) {
	if (reference instanceof sun.misc.Cleaner) {
		reference.dequeue();
		((sun.misc.Cleaner)reference).clean();
		return true;
	}
	synchronized(this) {
		if(!empty && head == tail) {
			/* Queue is full - grow */
			int newQueueSize = (int)(references.length * 1.10);
			Reference newQueue[] = new Reference[newQueueSize];
			System.arraycopy(references, head, newQueue, 0, references.length - head);
			if(tail > 0) {
				System.arraycopy(references, 0, newQueue, references.length - head, tail);
			}
			head = 0;
			tail = references.length;
			references = newQueue;
		}
		references[tail++] = reference;
		if(tail == references.length) {
			tail = 0;
		}
		empty = false;
		notifyAll();
	}
	return true;
}

4 楼 leonzhx 2010-10-01  

你说的ReferenceQueue贴出来是什么意思？
现在程序出的只是各种Reference的get()方法的输出。程序执行时就在

引用

while (null == r)  
            {  
                System.gc();  
                r = rq.poll();  
            }  

死循环了，说明ReferenceQueue里一直没东西。

3 楼 mercyblitz 2010-10-01  

leonzhx 写道

谢谢mercyblitz的指教。我更新了一下代码并加了一些注释。
首先，你贴的是ReferenceQueue的enqueue的代码吧？我这里JDK1.6好像不是长这样的。。。
其次，就是因为System.gc()靠不住，所以我加了/*********包起来的那段，但程序还是死循环。。。

没有错，你的ReferenceQueue贴出来呢！

2 楼 leonzhx 2010-10-01  

谢谢mercyblitz的指教。我更新了一下代码并加了一些注释。
首先，你贴的是ReferenceQueue的enqueue的代码吧？我这里JDK1.6好像不是长这样的。。。
其次，就是因为System.gc()靠不住，所以我加了/*********包起来的那段，但程序还是死循环。。。

1 楼 mercyblitz 2010-10-01  

代码没有怎么看明白!

一般而言，Strong、Soft、Weak和Phantom描述的是对象可达性，只有完全不可达时，对象才会真正的回收。

对象回收至少经过两个周期，前finalize期，可达性从Strong->Soft->Weak。

下个周期-finalize期，这个时候对象编程了，final reference（finalize可达性），在JDK中提供一个非public的类 - java.lang.ref.FinalReference。

SUN JDK源码中有提示：

 
boolean enqueue(Reference<? extends T> r) {	/* Called only by Reference class */
	synchronized (r) {
	    if (r.queue == ENQUEUED) return false;
	    synchronized (lock) {
		r.queue = ENQUEUED;
		r.next = (head == null) ? r : head;
		head = r;
		queueLength++;
                if (r instanceof FinalReference) { //
                    sun.misc.VM.addFinalRefCount(1); //添加final reference 计数
                }
		lock.notifyAll();
		return true;
	    }
	}
}

对象被finalized之后，对象的可达性为finalize。

而Phantom在finalize之后，这就是为什么引用对象总是返回null。

因此，SUN JDK里有5个可达性，按照强弱排列：Strong、Soft、Weak、Finalize和Phantom。

注意除了Phantom以外，ReferenceQueue都会返回被入队的引用。

另外，System.gc();  是靠不住的。所以，多次运行结果会不多。