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 the10      *       pending-Reference list.  Newly-created instances are Active.11      *       当垃圾回收器探测到引用的可达性变成某些适合的状态的时候，12      *       它会将该内部状态变成Pending或者Inactive，13      *       这取决于在实例化这个Reference对象的时候是否传入了ReferenceQueue。14      *     如果传入了，那么它同时会将该实例添加到pending-Reference列表中。15      *     新创建的引用对象是Active16      *17      *       Pending: An element of the pending-Reference list, waiting to be18      *       enqueued by the Reference-handler thread.  Unregistered instances19      *       are never in this state.20      *       一个在Pend-Reference列表中的元素，正等待着Reference-handler线程将他入队。21      *       未注册的实例不会出现在这个状态。22      *23      *       Enqueued: An element of the queue with which the instance was24      *       registered when it was created.  When an instance is removed from25      *       its ReferenceQueue, it is made Inactive.  Unregistered instances are26      *       never in this state.27      *       当一个实例从它的ReferenceQueue中被删除时，它变成Inactive状态。28      *       未注册的instance不会29      *30      *       Inactive: Nothing more to do.  Once an instance becomes Inactive its31      *       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, or37      *       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 instance44      *       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 order49      * to determine whether a Reference instance requires special treatment: If50      * 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,说明该实例为active55      * 如果不是null,说明回收器应该立刻处理该实例56      *57      * To ensure that concurrent collector can discover active Reference58      * objects without interfering with application threads that may apply59      * the enqueue() method to those objects, collectors should link60      * discovered objects through the discovered field.61      *62      * 为了保证并发收集器可以再不受应用程序线程调用enqueue()发放的影响下，发现active reference63      * 收集器应该吧已经发现的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来notify14                         } catch (InterruptedException x) { }15                         continue;16                     }17                 }18 19                 // Fast path for cleaners20                 // 钩子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             }