之前的这篇博客介绍了java中4种引用的差别和使用场景，在最后的总结中提到：

“软引用和弱引用差别不大，JVM都是先把SoftReference和WeakReference中的referent字段值设置成null，之后加入到引用队列；而虚引用则不同，如果某个堆中的对象，只有虚引用，那么JVM会将PhantomReference加入到引用队列中，JVM不会自动将referent字段值设置成null”。这段总结写的比较仓促，也没有给出实际的例子加以佐证。本文主要是重申下这几种引用的差别，并给出实际的例子，让读者清楚的感受到它们的差别。

软引用和弱引用差别不大，JVM都是先将其referent字段设置成null，之后将软引用或弱引用，加入到关联的引用队列中。我们可以认为JVM先回收堆对象占用的内存，然后才将软引用或弱引用加入到引用队列。

而虚引用则不同，JVM不会自动将虚引用的referent字段设置成null，而是先保留堆对象的内存空间，直接将PhantomReference加入到关联的引用队列，也就是说如果我们不手动调用PhantomReference.clear()，虚引用指向的堆对象内存是不会被释放的。

referent是java.lang.ref.Reference类的私有字段，虽然没有暴露出共有API来访问这个字段，但是我们可以通过反射拿到这个字段的值，这样就能知道引用被加入到引用队列的时候，referent到底是不是null。SoftReference和WeakReference是一样的，这里我们以WeakReference为例。

package ref.referent;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;

// 会报空指针:WeakReference中的referent被设置成null,之后加入到ReferenceQueue
public class TestWeakReference
{
	private static volatile boolean isRun = true;

	private static volatile ReferenceQueue<String> referenceQueue = new ReferenceQueue<String>();

	public static void main(String[] args) throws Exception
	{
		String abc = new String("abc");
		System.out.println(abc.getClass() + "@" + abc.hashCode());

		new Thread() {
			public void run()
			{
				while (isRun)
				{
					Object o = referenceQueue.poll();
					if (o != null)
					{
						try
						{
							Field rereferent = Reference.class
									.getDeclaredField("referent");
							rereferent.setAccessible(true);
							Object result = rereferent.get(o);
							System.out.println("gc will collect:"
									+ result.getClass() + "@"
									+ result.hashCode());
						} catch (Exception e)
						{
							e.printStackTrace();
						}
					}
				}
			}
		}.start();

		// 对象是弱可达的
		WeakReference<String> weak = new WeakReference<String>(abc,
				referenceQueue);
		System.out.println("weak=" + weak);

		// 清除强引用,触发GC
		abc = null;
		System.gc();

		Thread.sleep(3000);
		isRun = false;
	}
}

代码与上面类似， 我们将WeakReference替换成PhantomReference：

package ref.referent;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.reflect.Field;

// 当PhantomReference加入到ReferenceQueue的时候,目标对象内存空间仍然存在不会被回收.
// PhantomReference中的referent字段不会被JVM自动设置成null
// 当目标对象的PhantomReference加入到ReferenceQueue的时,此时目标对象是强可达的
public class TestPhantomReference
{
	private static volatile boolean isRun = true;

	private static volatile ReferenceQueue<String> referenceQueue = new ReferenceQueue<String>();

	public static void main(String[] args) throws Exception
	{
		String abc = new String("abc");
		System.out.println(abc.getClass() + "@" + abc.hashCode());

		new Thread() {
			public void run()
			{
				while (isRun)
				{
					Object o = referenceQueue.poll();
					if (o != null)
					{
						try
						{
							Field rereferent = Reference.class
									.getDeclaredField("referent");
							rereferent.setAccessible(true);
							Object result = rereferent.get(o);
							System.out.println("gc will collect:"
									+ result.getClass() + "@"
									+ result.hashCode());
						} catch (Exception e)
						{
							e.printStackTrace();
						}
					}
				}
			}
		}.start();

		// 测试情况1:对象是虚可达的
		PhantomReference<String> phantom = new PhantomReference<String>(abc,
				referenceQueue);
		System.out.println("phantom=" + phantom);

		// 测试情况2:对象是不可达的,直接就被回收了,不会加入到引用队列
		// new PhantomReference<String>(abc, referenceQueue);

		// 清除强引用,触发GC
		abc = null;
		System.gc();

		Thread.sleep(3000);
		isRun = false;
	}
}

class java.lang.String@96354
phantom=java.lang.ref.PhantomReference@15b7986
gc will collect:class java.lang.String@96354

很明显，当PhantomReference加入到引用队列的时候，referent字段的值并不是null，而且堆对象占用的内存空间仍然存在。也就是说对于虚引用，JVM是先将其加入引用队列，当我们从引用队列删除PhantomReference对象之后(此时堆中的对象是unreachable的)，那么JVM才会释放堆对象占用的内存空间。由此可见，使用虚引用有潜在的内存泄露风险，因为JVM不会自动帮助我们释放，我们必须要保证它指向的堆对象是不可达的。从这点来看，虚引用其实就是强引用，当内存不足的时候，JVM不会自动释放堆对象占用的内存。后续的帖子我会进行一些OOM相关的实验，去证明虚引用的确会导致OOM，而软引用和弱引用则不会导致OOM。

小结：

上面的测试代码，只是为了帮助我们看清楚虚引用与软引用/弱引用的不同表现。在实际的开发中，我们是不会通过反射获取referent字段的值，这样做毫无意义，也不值得提倡。

java中虚引用PhantomReference与弱引用WeakReference（软引用SoftReference）的差别