Java引用类型

 Object a=new Object(); 

public abstract class Reference<T> {	
    //引用的对象	
    private T referent;   
     	
    //回收队列，由使用者在Reference的构造函数中指定	
    volatile ReferenceQueue<? super T> queue;
	
     //当该引用被加入到queue中的时候，该字段被设置为queue中的下一个元素，以形成链表结构	
    volatile Reference  next;	

    //在GC时，HotSpot底层会维护一个叫DiscoveredList的链表，存放的是Reference对象，discovered字段指向的就是链表中的下一个元素，由HotSpot设置	
    transient private Reference<T>  discovered; 
 	
    //进行线程同步的锁对象	
    static private class Lock { }	
    private static Lock  lock = new Lock();
	
    //等待加入queue的Reference对象，在GC时由JVM设置，会有一个java层的线程(ReferenceHandler)源源不断的从pending中提取元素加入到queue	
    private static Reference<Object> pending = null;	
}

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

static boolean tryHandlePending(boolean waitForNotify) {	
        Reference<Object> r;	
        Cleaner c;	
        try {	
            synchronized (lock) {	
                if (pending != null) {	
                     r = pending;	
                     // 如果是Cleaner对象，则记录下来，下面做特殊处理	
                     c = r instanceof Cleaner ? (Cleaner) r : null;	
                     // 指向PendingList的下一个对象	
                     pending = r.discovered;	
                     r.discovered = null;	
                } else {	
                     // 如果pending为null就先等待，当有对象加入到PendingList中时，jvm会执行notify	
                     if (waitForNotify) {	
                         lock.wait();	
                     }	
                     // retry if waited	
                     return waitForNotify;	
                }	
            }	
        } 	
        ...	
        // 如果时Cleaner对象，则调用clean方法进行资源回收	
        if (c != null) {	
             c.clean();	
             return true;	
        }	
        // 将Reference加入到ReferenceQueue，开发者可以通过从ReferenceQueue中poll元素感知到对象被回收的事件。	
        ReferenceQueue<? super Object> q = r.queue;	
        if (q != ReferenceQueue.NULL) 
             q.enqueue(r);	
        return true;	
 }

public class ReferenceQueue<T> {

    public ReferenceQueue() { }
    
    // 内部类Null类继承自ReferenceQueue，覆盖了enqueue方法返回false
    private static class Null extends ReferenceQueue<Object> {
        boolean enqueue(Reference<?> r) {
            return false;
        }
    }
    
    // ReferenceQueue.NULL和ReferenceQueue.ENQUEUED都是内部类Null的新实例
    static final ReferenceQueue<Object> NULL = new Null();
    static final ReferenceQueue<Object> ENQUEUED = new Null();
    
    // 静态内部类，作为锁对象
    private static class Lock { };
    private final Lock lock = new Lock();

    // 引用链表的头节点
    private volatile Reference<? extends T> head;
    // 引用队列长度，入队则增加1，出队则减少1
    private long queueLength = 0;  

    // 入队操作，只会被Reference实例调用
    boolean enqueue(Reference<? extends T> r) {
        // 加锁
        synchronized (lock) {
            // Check that since getting the lock this reference hasn‘t already been
            // enqueued (and even then removed)
            // 如果引用实例持有的队列为ReferenceQueue.NULL或者ReferenceQueue.ENQUEUED，则入队失败返回false
            ReferenceQueue<?> queue = r.queue;
            if ((queue == NULL) || (queue == ENQUEUED)) {
                return false;
            }
            assert queue == this;
            // Self-loop end, so if a FinalReference it remains inactive.
            // 如果链表没有元素，则此引用实例直接作为头节点，否则把前一个引用实例作为下一个节点
            r.next = (head == null) ? r : head;
            // 当前实例更新为头节点，也就是每一个新入队的引用实例都是作为头节点，已有的引用实例会作为后继节点
            head = r;
            // 队列长度增加1
            queueLength++;
            // Update r.queue *after* adding to list, to avoid race
            // with concurrent enqueued checks and fast-path poll().
            // Volatiles ensure ordering.
            // 当前引用实例已经入队，那么它本身持有的引用队列实例置为ReferenceQueue.ENQUEUED
            r.queue = ENQUEUED;
            // 特殊处理FinalReference，VM进行计数
            if (r instanceof FinalReference) {
                VM.addFinalRefCount(1);
            }
            // 唤醒所有等待的线程
            lock.notifyAll();
            return true;
        }
    }

    // 引用队列的poll操作，此方法必须在加锁情况下调用
    private Reference<? extends T> reallyPoll() { 
        Reference<? extends T> r = head;
        if (r != null) {
            r.queue = NULL;
            // Update r.queue *before* removing from list, to avoid
            // race with concurrent enqueued checks and fast-path
            // poll().  Volatiles ensure ordering.
            @SuppressWarnings("unchecked")
            Reference<? extends T> rn = r.next;
            // Handle self-looped next as end of list designator.
            // 更新next节点为头节点，如果next节点为自身，那么队列中只有当前这个对象一个元素
            head = (rn == r) ? null : rn;
            // Self-loop next rather than setting to null, so if a
            // FinalReference it remains inactive.
            // 当前头节点变更为环状队列，考虑到FinalReference尚为inactive和避免重复出队的问题
            r.next = r;
            // 队列长度减少1
            queueLength--;
            // 特殊处理FinalReference，VM进行计数
            if (r instanceof FinalReference) {
                VM.addFinalRefCount(-1);
            }
            return r;
        }
        return null;
    }

    // 队列的公有poll操作，主要是加锁后调用reallyPoll
    public Reference<? extends T> poll() {
        if (head == null)
            return null;
        synchronized (lock) {
            return reallyPoll();
        }
    }
    
    // ...
}