public static void main(String[] args) {
        // 創(chuàng)建引用隊列
        ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
        // 創(chuàng)建obj對象
        Object obj = new Object();
        // 創(chuàng)建虛引用，虛引用引用了obj對象，并與queue進(jìn)行關(guān)聯(lián)
        PhantomReference<Object> phantomReference = new PhantomReference<Object>(obj, queue);
        // 創(chuàng)建obj1對象
        Object obj1 = new Object();
        PhantomReference<Object> phantomReference1 = new PhantomReference<Object>(obj1, queue);
        // 將obj置為NULL，強(qiáng)引用關(guān)系失效
        obj = null;
        // 垃圾回收
        System.gc();
        // 從引用隊列獲取對象
        Object o = queue.poll();
        if (null != o) {
            System.out.println(o.toString());
        }
    }

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {
    private final Cleaner cleaner;
        
    DirectByteBuffer(int cap) {                   // package-private
        super(-1, 0, cap, cap);
        boolean pa = VM.isDirectMemoryPageAligned();
        int ps = Bits.pageSize();
        long size = Math.max(1L, (long)cap + (pa ? ps : 0));
        // 清理內(nèi)存
        Bits.reserveMemory(size, cap);
        long base = 0;
        try {
            // 分配內(nèi)存
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        // 創(chuàng)建Cleader，傳入了當(dāng)前對象和Deallocator
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }
}

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {

    private static class Deallocator implements Runnable {
        // ...
        
        private Deallocator(long address, long size, int capacity) {
            assert (address != 0);
            this.address = address; // 設(shè)置內(nèi)存地址
            this.size = size;
            this.capacity = capacity;
        }

        public void run() {
            if (address == 0) {
                // Paranoia
                return;
            }
            // 釋放內(nèi)存
            unsafe.freeMemory(address);
            address = 0;
            Bits.unreserveMemory(size, capacity);
        }

    }
}

 public class Cleaner extends PhantomReference<Object>{

    // ReferenceQueue隊列
    private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue<>();

    // 靜態(tài)變量，鏈表的頭結(jié)點，創(chuàng)建的Cleaner都會加入到這個鏈表中
    static private Cleaner first = null;
     
    // thunk
    private final Runnable thunk;
     
    public static Cleaner create(Object ob, Runnable thunk) {
        if (thunk == null)
            return null;
        // 創(chuàng)建一個Cleaner并加入鏈表
        return add(new Cleaner(ob, thunk));
    }
    
    private Cleaner(Object referent, Runnable thunk) {
        super(referent, dummyQueue); // 調(diào)用父類構(gòu)造函數(shù)，傳入引用對象和引用隊列
        this.thunk = thunk; // thunk指向傳入的Deallocator
    }
     
    private static synchronized Cleaner add(Cleaner cl) {
        // 如果頭結(jié)點不為空
        if (first != null) {
            // 將新加入的節(jié)點作為頭結(jié)點
            cl.next = first; 
            first.prev = cl;
        }
        first = cl;
        return cl;
    }
}

public class PhantomReference<T> extends Reference<T> {
    // ...
    
    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q); // 調(diào)用父類構(gòu)造函數(shù)
    }

}

public abstract class Reference<T> {
    /* 引用對象 */
    private T referent;         
    // 引用隊列
    volatile ReferenceQueue<? super T> queue;
    
    Reference(T referent, ReferenceQueue<? super T> queue) {
        this.referent = referent;
        // 設(shè)置引用隊列
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }

}

public abstract class Reference<T> {
    static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        // 創(chuàng)建ReferenceHandler
        Thread handler = new ReferenceHandler(tg, "Reference Handler");
        // 設(shè)置優(yōu)先級為最高
        handler.setPriority(Thread.MAX_PRIORITY);
        handler.setDaemon(true);
        handler.start();

        // 這里設(shè)置了JavaLangRefAccess
        SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
            @Override
            public boolean tryHandlePendingReference() {
                // 調(diào)用了tryHandlePending
                return tryHandlePending(false);
            }
        });
    }
}

public abstract class Reference<T> {
    
    private static class ReferenceHandler extends Thread {
        
        // ...
        
        ReferenceHandler(ThreadGroup g, String name) {
            super(g, name);
        }

        public void run() {
            while (true) {
                // 處理pending列表
                tryHandlePending(true);
            }
        }
    }
 }

public abstract class Reference<T> {
  
    // 指向pending列表中的下一個節(jié)點
    transient private Reference<T> discovered; 

    // 靜態(tài)變量pending列表，可以看做是一個鏈表，pending指向鏈表的頭結(jié)點
    private static Reference<Object> pending = null;
  
    static boolean tryHandlePending(boolean waitForNotify) {
        Reference<Object> r;
        Cleaner c;
        try {
            synchronized (lock) {
                // 如果pending不為空
                if (pending != null) {
                    // 獲取pending執(zhí)行的對象
                    r = pending;
                    // 如果是Cleaner類型
                    c = r instanceof Cleaner ? (Cleaner) r : null;
                    // 將pending指向下一個節(jié)點
                    pending = r.discovered;
                    // 將discovered置為空
                    r.discovered = null;
                } else {
                    // 等待
                    if (waitForNotify) {
                        lock.wait();
                    }
                    return waitForNotify;
                }
            }
        } catch (OutOfMemoryError x) {
            Thread.yield();
            // retry
            return true;
        } catch (InterruptedException x) {
            // retry
            return true;
        }
        if (c != null) {
            // 調(diào)用clean方法進(jìn)行清理
            c.clean();
            return true;
        }
        // 獲取引用隊列
        ReferenceQueue<? super Object> q = r.queue;
        // 如果隊列不為空，將對象加入到引用隊列中
        if (q != ReferenceQueue.NULL) q.enqueue(r);
        // 返回true
        return true;
    }
}

public class Cleaner extends PhantomReference<Object> {

    public void clean() {
        if (!remove(this))
            return;
        try {
            // 調(diào)用run方法
            thunk.run();
        } catch (final Throwable x) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        if (System.err != null)
                            new Error("Cleaner terminated abnormally", x)
                                .printStackTrace();
                        System.exit(1);
                        return null;
                    }});
        }
    }
}

public class ReferenceQueue<T> {

    // head為鏈表頭節(jié)點
    private volatile Reference<? extends T> head = null;
}

public abstract class Reference<T> {

    /* When active:   處于active狀態(tài)時為NULL
     *     pending:   this
     *    Enqueued:   Enqueued狀態(tài)時，指向引用隊列中的下一個元素
     *    Inactive:   this
     */
    @SuppressWarnings("rawtypes")
    Reference next;
    
    /* When active:   active狀態(tài)時，指向GC維護(hù)的一個discovered鏈表中的下一個元素
     *     pending:   pending狀態(tài)時，指向pending列表中的下一個元素
     *   otherwise:   其他情況為NULL
     */
    transient private Reference<T> discovered;  /* used by VM */
}

public class ReferenceQueue<T> {

    // 空隊列
    static ReferenceQueue<Object> ENQUEUED = new Null<>();
    
    // 入隊，將節(jié)點加入引用隊列，隊列實際上是一個鏈表
    boolean enqueue(Reference<? extends T> r) {
        synchronized (lock) {
            // 獲取關(guān)聯(lián)的引用隊列
            ReferenceQueue<?> queue = r.queue;
            // 如果為空或者已經(jīng)添加到過隊列
            if ((queue == NULL) || (queue == ENQUEUED)) {
                return false;
            }
            assert queue == this;
            // 將引用隊列置為一個空隊列，表示該節(jié)點已經(jīng)入隊
            r.queue = ENQUEUED;
            // 如果頭結(jié)點為空將下一個節(jié)點置為自己，否則將next置為鏈表的頭結(jié)點，可以看出同樣使用的是頭插法將節(jié)點插入鏈表
            r.next = (head == null) ? r : head;
            // 更新頭結(jié)點為當(dāng)前節(jié)點
            head = r;
            // 增加長度
            queueLength++;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(1);
            }
            lock.notifyAll();
            return true;
        }
    }
}

public class ReferenceQueue<T> {
    /**
     * 從引用隊列中獲取一個節(jié)點，進(jìn)行出隊操作
     */
    public Reference<? extends T> poll() {
        // 如果頭結(jié)點為空，表示沒有數(shù)據(jù) 
        if (head == null)
            return null;
        synchronized (lock) {
            return reallyPoll();
        }
    }
    
    @SuppressWarnings("unchecked")
    private Reference<? extends T> reallyPoll() {     、  /* Must hold lock */
        // 獲取頭結(jié)點
        Reference<? extends T> r = head;
        if (r != null) {
            // 如果頭結(jié)點的下一個節(jié)點是自己，表示鏈表只有一個節(jié)點，head置為null，否則head值為r的下一個節(jié)點，也就是next指向的對象
            head = (r.next == r) ?
                null :
                r.next;
            // 將引用隊列置為NULL
            r.queue = NULL;
            // 下一個節(jié)點置為自己
            r.next = r;
            // 長度減一
            queueLength--;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(-1);
            }
            // 返回鏈表中的第一個節(jié)點
            return r;
        }
        return null;
    }
}

class Bits {

    static void reserveMemory(long size, int cap) {

        if (!memoryLimitSet && VM.isBooted()) {
            maxMemory = VM.maxDirectMemory();
            memoryLimitSet = true;
        }

        // 是否有足夠內(nèi)存
        if (tryReserveMemory(size, cap)) {
            return;
        }
        // 獲取JavaLangRefAccess
        final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
        // 調(diào)用tryHandlePendingReference
        while (jlra.tryHandlePendingReference()) {
            // 判斷是否有足夠的內(nèi)存
            if (tryReserveMemory(size, cap)) {
                return;
            }
        }

        // 調(diào)用gc進(jìn)行垃圾回收
        System.gc();

        boolean interrupted = false;
        try {
            long sleepTime = 1;
            int sleeps = 0;
            // 開啟循環(huán)
            while (true) {
                // 是否有足夠內(nèi)存
                if (tryReserveMemory(size, cap)) {
                    return;
                }
                // 如果次數(shù)小于最大限定次數(shù)，終止
                if (sleeps >= MAX_SLEEPS) {
                    break;
                }
                // 再次處理penging列表中的對象
                if (!jlra.tryHandlePendingReference()) {
                    try {
                        // 睡眠一段時間
                        Thread.sleep(sleepTime);
                        sleepTime <<= 1;
                        sleeps++; // 睡眠次數(shù)增加1
                    } catch (InterruptedException e) {
                        interrupted = true;
                    }
                }
            }
            // 拋出OutOfMemoryError異常
            throw new OutOfMemoryError("Direct buffer memory");

        } finally {
            if (interrupted) {
                // don't swallow interrupts
                Thread.currentThread().interrupt();
            }
        }
    }
}

public abstract class Reference<T> {
    static {
        // ...
        // 這里設(shè)置了JavaLangRefAccess
        SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
            @Override
            public boolean tryHandlePendingReference() {
                // 調(diào)用tryHandlePending,這里waitForNotify參數(shù)傳入的是false
                return tryHandlePending(false);
            }
        });
    }
}