Java RefenceQueue WeakHashMap
首先介绍Java中的四种引用：
- 强引用：如Object c = new Object（） 这种引用。如果一个对象有强应用，那么这个对象就不会被释放！即使内存不够时候，JVM会给出OutOfMemory异常。
- 软引用：SoftReference，软引用的对象，会在JVM内存不够的情况下被JVM回收。
- 弱引用：WeakReference，弱引用，在下一次GC的时候，会被GC清理。
- 虚引用：PhantomReference，形同虚设的引用，设置这个引用的对象，没法通过虚引用获得，这个引用设置一般也就是为了GC时候的一个提醒。
上面的SoftReference和WeakReference和PhantomReference，都是Reference的子类，我们来看看这个类的源码：
Reference的四种状态：
- Active：新建的Reference对象是处于这个状态的，（queue可能有，next为null）。
- Pending：等待被ReferenceHandler放入ReferenceQueue，如果Reference的Queue不存在，那么就不会处于这个状态，会被直接回收。（queue不为空，next=this）
- Enqueued：已经被加入ReferenceQueue的Reference对象，如果没有提供Queue，那么永远不会处于这个状态。如果从Queue中移出，就处于InActive状态。（queue = ReferenceQueue.Enqueued，next=ReferenceQueque的下一个元素。如果只有Queue中只有一个，那么就是this）
- InActive：这是最终的状态，一旦处于这个状态，就再也不会更改了。（queue = NULL，next = this）
private T referent : 属性，这个属性的是泛型T，代表，引用的具体指向对象。
volatile ReferenceQueue<? super T> queue：Reference的Queue对象。
Reference next ： 这个属性和Queue一起组成了四种状态的标志。
Reference<T> discovered：这个字段是虚拟机使用的，用来标识，下一个GC的Reference对象。
Reference<Object> pending ： 这个字段代表，等待被处理的Reference的对象，这个对象一般被ReferenceHandler线程所消费！
内部类 ReferenceHandler ：
private static class ReferenceHandler extends Thread
public void run() {
while (true) {
tryHandlePending(true);
}
}
继承自Thread，提供了一个很特别的run方法，死循环运行tryHandlePending方法。
static boolean tryHandlePending(boolean waitForNotify) {
Reference<Object> r;
Cleaner c;
try {
synchronized (lock) { //加锁，确保读取到的是最新的pending对象
if (pending != null) {
r = pending; //r表示正在处理的Reference对象！
// 'instanceof' might throw OutOfMemoryError sometimes
// so do this before un-linking 'r' from the 'pending' chain...
c = r instanceof Cleaner ? (Cleaner) r : null;
// unlink 'r' from 'pending' chain
pending = r.discovered; // 将下一个GC的对象放入pending
r.discovered = null; / 将discovered去除。
} else {
// The waiting on the lock may cause an OutOfMemoryError
// because it may try to allocate exception objects.
if (waitForNotify) {
lock.wait(); //如果没有等待处理的Reference对象，就进入等待，这个由JVM唤醒的
}
// retry if waited
return waitForNotify;
}
}
} catch (OutOfMemoryError x) {
// Give other threads CPU time so they hopefully drop some live references
// and GC reclaims some space.
// Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above
// persistently throws OOME for some time...
Thread.yield();
// retry
return true;
} catch (InterruptedException x) {
// retry
return true;
}
// Fast path for cleaners
if (c != null) {
c.clean();
return true;
}
ReferenceQueue<? super Object> q = r.queue; //取出Reference的Queue
if (q != ReferenceQueue.NULL) q.enqueue(r); //如果Queue不为NULL，就做入队的操作。
return true;
}
需要注意的是：ReferenceHandler这个线程是在Reference类被加载的时候，启动的！优先级最高，后台线程！
至此Reference的我们就分析完毕了！我们明白了，Reference是通过Reference的Handler，不断的将GC标记的Reference放入Queue中的！
我们再来看下ReferenceQueue的源码：
ReferenceQueue<Object> NULL：给没有设置Queue的Reference对象设置一个默认的Queue。但是无法做入队的操作。
ReferenceQueue<Object> ENQUEUED：对已经放入Queue的Reference对象，将其的Queue设置为ENQUEUED。
Reference<? extends T> head：队列的头。其实ReferenceQueue是个链表。
从上面的ReferenceHandler中我们看到，线程会不断的执行Queue的enqueue对象：下面解析这个方法的源码：
boolean enqueue(Reference<? extends T> r) { /* Called only by Reference class */
synchronized (lock) {
// Check that since getting the lock this reference hasn't already been
// enqueued (and even then removed)
ReferenceQueue<?> queue = r.queue;
if ((queue == NULL) || (queue == ENQUEUED)) { //如果queue是NULL或者ENQUEUED就不做处理。
return false;
}
assert queue == this;
r.queue = ENQUEUED; //将原来的Reference对象的Queue设置为ENQUEUED
r.next = (head == null) ? r : head; //将当前处理的Reference设置为队列的头部
head = r;
queueLength++;
if (r instanceof FinalReference) {
sun.misc.VM.addFinalRefCount(1);
}
lock.notifyAll(); //唤醒阻塞的方法，如remove方法。
return true;
}
}
Queue中，还有一些方法，我们一个个解析：
poll方法，最终调用的是 reallyPoll 方法：检测队列是否为空，不为空就处理头部元素，返回头部元素，或者null。
remove方法，最终调用remove（timeout）方法！如果timeout为0，表示如果没有元素会一直等待！如果大于0，如果队列为空就等待一段时间。
Reference和ReferenceQueue的源码，讲解结束！总结下就是，ReferenceQueue的作用就是在Reference的内部元素被GC回收的时候，会把Reference加入到Queue中，然后我们通过监听Queue的元素，可以得到元素被回收的事件，针对这个事件，我们可以做其他事情。
WeakHashMap中，比较常用的使用了Reference的知识，下面我们来看看它的源码：
WeakHashMap的源码分析：
首先我们要知道WeakHashMap和普通的Map的不同：
WeakHashMap的元素是会变化的。
WeakHashMap的Entry的Key是WeakReference，所以在Key，可以被回收的时候，可以得到相应的通知！
WeakHashMap 在 put,get和Size操作的时候都会执行expungeStaleEntries（去除多余的Entry）的方法，将无用的Key的对应的Entry移除掉！
在我们使用WeakHashMap的时候需要注意的是，尽量的防止，Key和Value使用同一个对象！如String是一个不变的对象，如果设置了一个“GOOD”的Key，也设置了一个“GOOD”的Value，String的对象是会被缓存的，所以其实Key和Value此时都是一个对象！但是Value是强引用，所以这个Key也永远无法被标记清除，就失去了WeakHashMap的意义了。在使用String作为WeakHashMap的Key的时候一定要小心，最好使用new String()包装一层，否则String会使用的是String缓冲池的数据，导致WeakHashMap的泄露！如果某些情况，Key必须和Value 相同，那么可以有两种方法解决！：第一种，从Key中深Copy元素，产生Value，此时Key和Value，是不同的元素！第二种，对Value也使用一个WeakReference！
WeakHashMap的大体思路是，Key是一个WeakHashMap，当Key可以回收的时候，我们就通过Key找到相应的Entry，然后移除Value。当每次Put，GET，Size相关操作的时候，就会去检查是否有相应的Key可以回收。
我们直接来看WeakHashMap里最重要的检测回收的方法：
private void expungeStaleEntries() {
for (Object x; (x = queue.poll()) != null; ) { //通过poll方法，不断轮询Queue的元素
synchronized (queue) {
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) x;
int i = indexFor(e.hash, table.length); //通过hash找到index
// WeakHashMap和HashMap是一样的，都有BuUket的概念，Buket之下是链表的概念dou'yo
Entry<K,V> prev = table[i];
Entry<K,V> p = prev;
while (p != null) {
Entry<K,V> next = p.next;
if (p == e) {
if (prev == e)
table[i] = next;
// p == e && pre == e 那么久表示是第一个元素
else
prev.next = next; //不是第一个元素
// Must not null out e.next;
// stale entries may be in use by a HashIterator
//上面的作用就是删除链表中的e这个元素。
e.value = null; // Help GC //将e的Value设置为null
size--;
break;
}
prev = p;
p = next;
}
}
}
}
