Java 源码剖析——彻底搞懂 Reference 和 ReferenceQueue

之前博主的一篇读书笔记——《深入理解 Java 虚拟机》系列之回收对象算法与四种引用类型博客中为大家介绍了 Java 中的四种引用类型，很多同学都希望能够对引用，还有不同类型引用的原理进行更深入的了解。因此博主查看了抽象父类 Reference 和负责注册引用对象的引用队列 ReferenceQueue 的源码，在此和大家一起分享，并做了一些分析，感兴趣的同学可以一起学习。

Reference 源码分析

首先我们先看一下 Reference 类的注释：

/**
 * Abstract base class for reference objects.  This class defines the
 * operations common to all reference objects.  Because reference objects are
 * implemented in close cooperation with the garbage collector, this class may
 * not be subclassed directly.
 引用对象的抽象基类。此类定义了常用于所有引用对象的操作。因为引用对象是通过与垃圾回收器的密切合作来实现的，所以不能直接为此类创建子类。
 */
​

该类提供了两个构造函数：

Reference(T referent) {
	this(referent, null);
}

Reference(T referent, ReferenceQueue<? super T> queue) {
        this.referent = referent;
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}
​

一个构造函数带需要注册到的引用队列，一个不带。带 queue 的意义在于我们可以吃从外部通过对 queue 的操作来了解到引用实例所指向的实际对象是否被回收了，同时我们也可以通过 queue 对引用实例进行一些额外的操作；但如果我们的引用实例在创建时没有指定一个引用队列，那我们要想知道实际对象是否被回收，就只能够不停地轮询引用实例的 get()方法是否为空了。值得注意的是虚引用 PhantomReference，由于它的 get()方法永远返回 null，因此它的构造函数必须指定一个引用队列。这两种查询实际对象是否被回收的方法都有应用，如 weakHashMap 中就选择去查询 queue 的数据，来判定是否有对象将被回收；而 ThreadLocalMap，则采用判断 get()是否为 null 来作处理。

接下来是它的主要成员：

private T referent;         /* Treated specially by GC */
​

在这里我们首先明确一些名词，Reference 类也被称为引用类，它的实例 Reference Instance 就是引用实例，但是由于它是一个抽象类，它的实例只能是子类软(soft)引用,弱(weak)引用,虚(phantom)引用中的某个，至于引用实例所引用的对象我们称之为实际对象(也就是我们上面所写出的 referent)。

volatile ReferenceQueue<? super T> queue;   /* 引用对象队列*/
​

queue 是当前引用实例所注册的引用队列，一旦实际对象的可达性发生适当的变化后，此引用实例将会被添加到 queue 中。

/* When active:   NULL
 *     pending:   this
 *    Enqueued:   next reference in queue (or this if last)
 *    Inactive:   this
 */
@SuppressWarnings("rawtypes")
Reference next;
​

next 用来表示当前引用实例的下一个需要被处理的引用实例，我们在注释中看到的四个状态，是引用实例的内部状态，不可以被外部查看或是直接修改：

• Active：新创建的引用实例处于 Active 状态，但当 GC 检测到该实例引用的实际对象的可达性发生某些适当的改变(实际对象对于 GC roots 不可达)后，它的状态将会根据此实例是否注册在引用队列中而变成 Pending 或是 Inactive。
• Pending：当引用实例被放置在 pending-Reference list 中时，它处于 Pending 状态。此时，该实例在等待一个叫 Reference-handler 的线程将此实例进行 enqueue 操作。如果某个引用实例没有注册在一个引用队列中，该实例将永远不会进入 Pending 状态。
• Enqueued： 当引用实例被添加到它注册在的引用队列中时，该实例处于 Enqueued 状态。当某个引用实例被从引用队列中删除后，该实例将从 Enqueued 状态变为 Inactive 状态。如果某个引用实例没有注册在一个引用队列中，该实例将永远不会进入 Enqueued 状态。
• Inactive：一旦某个引用实例处于 Inactive 状态，它的状态将不再会发生改变，同时说明该引用实例所指向的实际对象一定会被 GC 所回收。

事实上 Reference 类并没有显示地定义内部状态值，JVM 仅需要通过成员 queue 和 next 的值就可以判断当前引用实例处于哪个状态：

• Active：queue 为创建引用实例时传入的 ReferenceQueue 的实例或是 ReferenceQueue.NULL；next 为 null
• Pending：queue 为创建引用实例时传入的 ReferenceQueue 的实例；next 为 this
• Enqueued：queue 为 ReferenceQueue.ENQUEUED；next 为队列中下一个需要被处理的实例或是 this 如果该实例为队列中的最后一个
• Inactive：queue 为 ReferenceQueue.NULL；next 为 this

/* List of References waiting to be enqueued.  The collector adds
 * References to this list, while the Reference-handler thread removes
 * them.  This list is protected by the above lock object. The
 * list uses the discovered field to link its elements.
 */
private static Reference<Object> pending = null;

/* When active:   next element in a discovered reference list maintained by GC (or this if last)
 *     pending:   next element in the pending list (or null if last)
 *   otherwise:   NULL
 */
transient private Reference<T> discovered;  /* used by VM */
​

看到注释的同学们有可能会有一些疑惑，明明 pending 是一个 Reference 类型的对象，为什么注释说它是一个 list 呢？其实是因为 GC 检测到某个引用实例指向的实际对象不可达后，会将该 pending 指向该引用实例，discovered 字段则是用来表示下一个需要被处理的实例，因此我们只要不断地在处理完当前 pending 之后，将 discovered 指向的实例赋予给 pending 即可。所以这个 static 字段 pending 其实就是一个链表。

private static class ReferenceHandler extends Thread {
  ......
  public void run() {
	  while (true) {
		  tryHandlePending(true);
	  }
  }
}
​

ReferenceHandler 是一个优先级最高的线程，它执行的工作就是将 pending list 中的引用实例添加到引用队列中，并将 pending 指向下一个引用实例。

 static boolean tryHandlePending(boolean waitForNotify) {
	 ......
	 synchronized (lock) {
		if (pending != null) {
			r = pending;
			// 'instanceof' might throw OutOfMemoryError sometimes
			// so do this before un-linking 'r' from the 'pending' chain...
			c = r instanceof Cleaner ? (Cleaner) r : null;
			// unlink 'r' from 'pending' chain
			pending = r.discovered;
			r.discovered = null;
		}
	}
	......
	ReferenceQueue<? super Object> q = r.queue;
        if (q != ReferenceQueue.NULL) q.enqueue(r);
        return true;
 }
​

Reference 对外提供的方法就比较简单了：

public T get() {
   return this.referent;
}
​

get()方法就是简单的返回引用实例所引用的实际对象，如果该对象被回收了或者该引用实例被 clear 了则返回 null

public void clear() {
  this.referent = null;
}
​

调用此方法不会导致此对象入队。此方法仅由 Java 代码调用；当垃圾收集器清除引用时，它直接执行，而不调用此方法。
clear 的方法本质上就是将 referent 置为 null，清除引用实例所引用的实际对象，这样通过 get()方法就不能再访问到实际对象了。

public boolean isEnqueued() {
  return (this.queue == ReferenceQueue.ENQUEUED);
}
​

判断此引用实例是否已经被放入队列中是通过引用队列实例是否等于 ReferenceQueue.ENQUEUED 来得知的。

public boolean enqueue() {
  return this.queue.enqueue(this);
}
​

enqueue()方法能够手动将引用实例加入到引用队列当中去。

ReferenceQueue 源码分析

同样我们先看一下 ReferenceQueue 的注释：

/**
 * Reference queues, to which registered reference objects are appended by the
 * garbage collector after the appropriate reachability changes are detected.
 * 引用队列，在检测到适当的可到达性更改后，垃圾回收器将已注册的引用对象添加到该队列中
 */
​

ReferenceQueue 实现了队列的入队(enqueue)和出队(poll)，其中的内部元素就是我们上文中提到的 Reference 对象。队列元素的存储结构是单链式存储，依靠每个 reference 对象的 next 域去找下一个元素。

主要成员有：

private  volatile Reference extends T> head = null;
​

用来存储当前需要被处理的节点

static ReferenceQueue NULL = new Null<>();
static ReferenceQueue ENQUEUED = new Null<>();
​

static 变量 NUlL 和 ENQUEUED 分别用来表示没有提供默认引用队列的空队列和已经执行过 enqueue 操作的队列。

引用实例入队的逻辑很简单：

synchronized (lock) {
	// 检查reference是否已经执行过入队操作
	ReferenceQueue<?> queue = r.queue;
	if ((queue == NULL) || (queue == ENQUEUED)) {
		return false;
	}
	//将引用实例的成员queue置为ENQUEUED
	r.queue = ENQUEUED;
	//若头节点为空，说明该引用实例为队列中的第一个元素，将它的next实例等于this
	//若头节点不为空，将它的next实例指向头节点指向的元素
	r.next = (head == null) ? r : head;
	//头节点指向当前引用实例
	head = r;
	//length＋1
	queueLength++;

	lock.notifyAll();
	return true;
}
​

简单来说，入队操作就是将每次需要入队的引用实例放在头节点的位置，并将它的 next 域指向旧的头节点元素。因此整个 ReferenceQueue 是一个后进先出的数据结构。

出队的逻辑为：

r指向头节点元素
Reference<? extends T> r = head;
if (r != null) {
	//头节点指向null，如果队列中只有一个元素；否则指向r.next
	head = (r.next == r) ? null : r.next; 
	//头节点元素的queue指向ReferenceQueue.NULL
	r.queue = NULL;
	//将r.next指向this
	r.next = r;
	//length-1
	queueLength--;
	
	return r;
}
​

总体来看，ReferenceQueue 的作用就是 JAVA GC 与 Reference 引用对象之间的中间层，我们可以在外部通过 ReferenceQueue 及时地根据所监听的对象的可达性状态变化而采取处理操作。