java编程Reference核心原理示例源码分析

static {
    //省略部分代码...
    Thread handler = new ReferenceHandler(tg, "Reference Handler");
    handler.setPriority(Thread.MAX_PRIORITY);
    handler.setDaemon(true);
    handler.start();
    //省略部分代码...
}

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;
                //instanceof 可能会抛出OOME，所以在将r从pending链上断开前，做这个处理
                c = r instanceof Cleaner ? (Cleaner) r : null;
                //将将r从pending链上断开
                pending = r.discovered;
                r.discovered = null;
            } else {
                //等待CG后的通知
                if (waitForNotify) {
                    lock.wait();
                }
                //重试
                return waitForNotify;
            }
        }
    } catch (OutOfMemoryError x) {
        //当抛出OOME时，放弃CPU的运行时间，这样有希望收回一些存活的引用并且GC能回收部分空间。同时能避免频繁地自旋重试，导致连续的OOME异常
        Thread.yield();
        //重试
        return true;
    } catch (InterruptedException x) {
         //重试
        return true;
    }
    //如果是Cleaner类型的Reference调用其clean方法并退出
    if (c != null) {
        c.clean();
        return true;
    }
    ReferenceQueue<? super Object> q = r.queue;
    //如果Reference有注册ReferenceQueue，则处理pending指向的Reference结点将其加入ReferenceQueue中
    if (q != ReferenceQueue.NULL) q.enqueue(r);
    return true;
}

public abstract class Reference<T> {
// Reference 引用的对象
private T referent;

volatile ReferenceQueue<? super T> queue;
// 可理解为注册的queue中的下一个结点的引用。其取值会根据Reference不同状态发生改变，具体取值见上面的分析
volatile Reference next;

transient private Reference<T> discovered;

private static Reference<Object> pending = null;
// 可理解为注册的queue中的下一个结点的引用。其取值会根据Reference不同状态发生改变，具体取值见上面的分析
volatile Reference next;
//用于CG同步Reference成员变量值的对象。
static private class Lock { }
private static Lock lock = new Lock();
//省略部分代码...
}

//构造函数，指定引用的对象referent
Reference(T referent) {
    this(referent, null);
}
//构造函数，指定引用的对象referent与注册的queue
Reference(T referent, ReferenceQueue<? super T> queue) {
    this.referent = referent;
    this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}
//获取引用的对象referent
public T get() {
    return this.referent;
}
//将当前对象加入创建时注册的queue中
public boolean enqueue() {
    return this.queue.enqueue(this);
}

//代表Reference的queue为null。Null为ReferenceQueue子类
static ReferenceQueue<Object> NULL = new Null<>();
//代表Reference已加入当前ReferenceQueue中。
static ReferenceQueue<Object> ENQUEUED = new Null<>();
//用于同步的对象
private Lock lock = new Lock();
//当前ReferenceQueue中的头节点
private volatile Reference<? extends T> head = null;
//ReferenceQueue的长度
private long queueLength = 0;

//入列队enqueue方法，只被Reference类调用，也就是上面分析中ReferenceHandler线程为调用
boolean enqueue(Reference<? extends T> r) {
	//获取同步对象lock对应的监视器对象
    synchronized (lock) {
        //获取r关联的ReferenceQueue，如果创建r时未注册ReferenceQueue则为NULL，同样如果r已从ReferenceQueue中移除其也为null
        ReferenceQueue<?> queue = r.queue;
        //判断queue是否为NULL 或者 r已加入ReferenceQueue中，是的话则入队列失败
        if ((queue == NULL) || (queue == ENQUEUED)) {
            return false;
        }
        assert queue == this;
        //设置r的queue为已入队列
        r.queue = ENQUEUED;
        //如果ReferenceQueue头节点为null则r的next节点指向当前节点，否则指向头节点
        r.next = (head == null) ? r : head;
        //更新ReferenceQueue头节点
        head = r;
        //列队长度加1
        queueLength++;
        //为FinalReference类型引用增加FinalRefCount数量
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(1);
        }
        //通知remove操作队列有节点
        lock.notifyAll();
        return true;
    }
}

public Reference<? extends T> poll() {
    //头结点为null直接返回，代表Reference还没有加入ReferenceQueue中
    if (head == null)
        return null;
    //获取同步对象lock对应的监视器对象
    synchronized (lock) {
        return reallyPoll();
    }
}
//从队列中真正poll元素的方法
private Reference<? extends T> reallyPoll() {
    Reference<? extends T> r = head;
    //double check 头节点不为null
    if (r != null) {
    	//保存头节点的下个节点引用
        Reference<? extends T> rn = r.next;
        //更新queue头节点引用
        head = (rn == r) ? null : rn;
        //更新Reference的queue值，代表r已从队列中移除
		r.queue = NULL;
		//更新Reference的next为其本身
        r.next = r;
        queueLength--;
        //为FinalReference节点FinalRefCount数量减1
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(-1);
        }
        //返回获取的节点
        return r;
    }
    return null;
}

public Reference<? extends T> remove(long timeout) throws IllegalArgumentException, InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Negative timeout value");
    }
    //获取同步对象lock对应的监视器对象
    synchronized (lock) {
    	//获取队列头节点指向的Reference
        Reference<? extends T> r = reallyPoll();
        //获取到返回
        if (r != null) return r;
        long start = (timeout == 0) ? 0 : System.nanoTime();
        //在timeout时间内尝试重试获取
        for (;;) {
        	//等待队列上有结点通知
            lock.wait(timeout);
            //获取队列中的头节点指向的Reference
            r = reallyPoll();
            //获取到返回
            if (r != null) return r;
            if (timeout != 0) {
                long end = System.nanoTime();
                timeout -= (end - start) / 1000_000;
                //已超时但还没有获取到队列中的头节点指向的Reference返回null
                if (timeout <= 0) return null;
                start = end;
            }
        }
    }
}

//继承了PhantomReference类也就是虚引用，PhantomReference源码很简单只是重写了get方法返回null
public class Cleaner extends PhantomReference<Object> {
	
    private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue();
    //Cleaner链表的头结点
    private static Cleaner first = null;
    //当前Cleaner节点的后续节点
    private Cleaner next = null;
    //当前Cleaner节点的前续节点
    private Cleaner prev = null;
    //真正执行清理工作的Runnable对象，实际clean内部调用thunk.run()方法
    private final Runnable thunk;
    //省略部分代码...
}

//私有方法，不能直接new
private Cleaner(Object var1, Runnable var2) {
    super(var1, dummyQueue);
    this.thunk = var2;
}
//创建Cleaner对象，同时加入Cleaner链中。
public static Cleaner create(Object var0, Runnable var1) {
    return var1 == null ? null : add(new Cleaner(var0, var1));
}
//头插法将新创意的Cleaner对象加入双向链表，synchronized保证同步
private static synchronized Cleaner add(Cleaner var0) {
    if (first != null) {
        var0.next = first;
        first.prev = var0;
    }
    //更新头节点引用
    first = var0;
    return var0;
}

public void clean() {
	//从Cleaner链表中先移除当前节点
    if (remove(this)) {
        try {
        	//调用thunk.run()方法执行对应清理逻辑
            this.thunk.run();
        } catch (final Throwable var2) {
           //省略部分代码..
        }

    }
}

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer(int cap) {
    //省略部分代码...
    try {
    	//调用unsafe分配内存
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
       //省略部分代码...
    }
    //省略部分代码...
    //前面分析中的Cleaner对象创建，持有当前DirectByteBuffer的引用
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    //通过unsafe.freeMemory释放创建的堆外内存
    unsafe.freeMemory(address);
    address = 0;
    Bits.unreserveMemory(size, capacity);
}

//Entry继承了WeakReference, WeakReference引用的是Map的key
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
    V value;
    final int hash;
    Entry<K,V> next;
    
    Entry(Object key, V value,
          ReferenceQueue<Object> queue,
          int hash, Entry<K,V> next) {
        super(key, queue);
        this.value = value;
        this.hash  = hash;
        this.next  = next;
    }
    //省略部分原码...
}

private void expungeStaleEntries() {
    //不断地从ReferenceQueue中取出，那些只有被WeakReference对象引用的对象的Reference
    for (Object x; (x = queue.poll()) != null; ) {
        synchronized (queue) {
            //转为 entry
            Entry<K,V> e = (Entry<K,V>) x;
            //计算其对应的桶的下标
            int i = indexFor(e.hash, table.length);
            //取出桶中元素
            Entry<K,V> prev = table[i];
            Entry<K,V> p = prev;
            //桶中对应位置有元素，遍历桶链表所有元素
            while (p != null) {
                Entry<K,V> next = p.next;
                //如果当前元素(也就是entry)与queue取出的一致，将entry从链表中去除
                if (p == e) {
                    if (prev == e)
                        table[i] = next;
                    else
                        prev.next = next;
                    // Must not null out e.next;
                    //清空entry对应的value
                    e.value = null;
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}