1  /* A Reference instance is in one of four possible internal states:
 2        一个Reference实例有以下4种内部状态
 3      *
 4      *       Active: Subject to special treatment by the garbage collector.  Some
 5      *       time after the collector detects that the reachability of the
 6      *       referent has changed to the appropriate state, it changes the
 7      *       instance‘s state to either Pending or Inactive, depending upon
 8      *       whether or not the instance was registered with a queue when it was
 9      *       created.  In the former case it also adds the instance to the
10      *       pending-Reference list.  Newly-created instances are Active.
11      *       当垃圾回收器探测到引用的可达性变成某些适合的状态的时候，
12      *       它会将该内部状态变成Pending或者Inactive，
13      *       这取决于在实例化这个Reference对象的时候是否传入了ReferenceQueue。
14      *     如果传入了，那么它同时会将该实例添加到pending-Reference列表中。
15      *     新创建的引用对象是Active
16      *
17      *       Pending: An element of the pending-Reference list, waiting to be
18      *       enqueued by the Reference-handler thread.  Unregistered instances
19      *       are never in this state.
20      *       一个在Pend-Reference列表中的元素，正等待着Reference-handler线程将他入队。
21      *       未注册的实例不会出现在这个状态。
22      *
23      *       Enqueued: An element of the queue with which the instance was
24      *       registered when it was created.  When an instance is removed from
25      *       its ReferenceQueue, it is made Inactive.  Unregistered instances are
26      *       never in this state.
27      *       当一个实例从它的ReferenceQueue中被删除时，它变成Inactive状态。
28      *       未注册的instance不会
29      *
30      *       Inactive: Nothing more to do.  Once an instance becomes Inactive its
31      *       state will never change again.
32      *       不会再做任何改变。一旦某个实例变成了Inactive态，它的状态不会再有任何改变。
33      *
34      * The state is encoded in the queue and next fields as follows:
35      *
36      *       Active: queue = ReferenceQueue with which instance is registered, or
37      *       ReferenceQueue.NULL if it was not registered with a queue; next =
38      *       null.
39      *
40      *       Pending: queue = ReferenceQueue with which instance is registered;
41      *       next = Following instance in queue, or this if at end of list.
42      *
43      *       Enqueued: queue = ReferenceQueue.ENQUEUED; next = Following instance
44      *       in queue, or this if at end of list.
45      *
46      *       Inactive: queue = ReferenceQueue.NULL; next = this.
47      *
48      * With this scheme the collector need only examine the next field in order
49      * to determine whether a Reference instance requires special treatment: If
50      * the next field is null then the instance is active; if it is non-null,
51      * then the collector should treat the instance normally.
52      *
53      * 以这种方式，收集器只需要检查next字段，以决定是否该引用实例应该被特殊处理
54      * 如果下一个字段是null,说明该实例为active
55      * 如果不是null,说明回收器应该立刻处理该实例
56      *
57      * To ensure that concurrent collector can discover active Reference
58      * objects without interfering with application threads that may apply
59      * the enqueue() method to those objects, collectors should link
60      * discovered objects through the discovered field.
61      *
62      * 为了保证并发收集器可以再不受应用程序线程调用enqueue()发放的影响下，发现active reference
63      * 收集器应该吧已经发现的objects通过discovered 字段表示。
64      *
65      */

     /* Object used to synchronize with the garbage collector.  The collector
     * must acquire this lock at the beginning of each collection cycle.  It is
     * therefore critical that any code holding this lock complete as quickly
     * as possible, allocate no new objects, and avoid calling user code.
     * 这是垃圾回收器用来同步的对象。在垃圾回收周期之前，回收器需要获取这个锁。
     * 因此，任何持有该锁的对象应该尽快执行完，尽量不要分配新对象，避免调用用户代码
     */

 1   for (;;) {
 2 
 3                 Reference r;
 4                 synchronized (lock) {
 5                     if (pending != null) {
 6                         //删除pending列表的该对象
 7                         r = pending;
 8                         Reference rn = r.next;
 9                         pending = (rn == r) ? null : rn;
10                         r.next = r;
11                     } else {
12                         try {
13                             lock.wait(); //该wait由VM来notify
14                         } catch (InterruptedException x) { }
15                         continue;
16                     }
17                 }
18 
19                 // Fast path for cleaners
20                 // 钩子
21                 if (r instanceof Cleaner) {
22                     ((Cleaner)r).clean();
23                     continue;
24                 }
25 
26                 ReferenceQueue q = r.queue;
27                 //将该对象入队
28                 //加入ReferenceQueue中的链表中，见下文
29                 if (q != ReferenceQueue.NULL) q.enqueue(r);
30             }