WeakHashMap总结

WeakHashMap利用WeakReference的弱引用特性让用户在使用的过程中不会因为没有释放Map中的资源而导致内存泄露。WeakHashMap实现了Map接口，使用方式和其他的Map相同，需要注意的是get方法和size方法的使用。在介绍WeakHashMap之前需要先介绍一下Reference的概念。

1、Reference的实现

public abstract class Reference<T> {
    private T referent;   //对应的引用对象
    volatile ReferenceQueue<? super T> queue; //引用队列，初始化的时候从外部传入
    Reference next;  // 当引用对象可达性发生变化的时候，next会指向当前引用
    transient private Reference<T> discovered;  /* used by VM */
    static private class Lock { } 
    private static Lock lock = new Lock(); //用来同步锁操作
}

Reference类有四个直接子类，PhantomReference、FinalReference、SoftReference、WeakReference。其中SoftReference比WeakReference约束要强一些，当内存不够用的时候JVM才会将对应引用的对象删除掉，而WeakReference在对象引用不可达的时候就会被JVM清理掉，PhantomReference（虚引用）和约束更弱，get方法永远都返回null，无法像前两者一样可以通过get()方法获取一个强引用，PhantomReference只能用来监控对象的GC状况。
无论哪种Reference，都有一个重要的对象来跟踪对象的gc动作，这个就是ReferenceQueue。

2、ReferenceQueue的实现

public class ReferenceQueue {
    static private class Lock { }; //锁对象，用来同步队列操作
    private Lock lock = new Lock(); 
    private volatile Reference<? extends T> head = null; //头结点
    private long queueLength = 0; //队列长度
}

a、入队操作

boolean enqueue(Reference<? extends T> r) { /* Called only by Reference class */
   synchronized (lock) {
        ReferenceQueue<?> queue = r.queue; //获取reference之前的队列，如果没有绑定队列，那就不需要入队
        if ((queue == NULL) || (queue == ENQUEUED)) {
            return false;
        }
        assert queue == this;
        r.queue = ENQUEUED;
        r.next = (head == null) ? r : head; //把r从链表的头部插入
        head = r; //头结点指向r
        queueLength++; //队列长度+1
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(1);
        }
        lock.notifyAll(); //唤醒删除线程删除头结点
        return true;
    }
}

出队列的操作相似，每个reference就是链表中的一个节点，next指向下一个reference节点。
b、删除操作

public Reference<? extends T> remove(long timeout)
    throws IllegalArgumentException, InterruptedException
{
    if (timeout < 0) {
        throw new IllegalArgumentException("Negative timeout value");
    }
    synchronized (lock) {
        Reference<? extends T> r = reallyPoll(); //尝试获取队列的头结点
        if (r != null) return r; //获取成功，返回
        long start = (timeout == 0) ? 0 : System.nanoTime(); //如果超时时间不为0，就记录一下当前的开始时间
        for (;;) {
            lock.wait(timeout);
            r = reallyPoll();
            if (r != null) return r;
            if (timeout != 0) {
                long end = System.nanoTime();
                timeout -= (end - start) / 1000_000; //计算一下等待的时间
                if (timeout <= 0) return null; //确认等待是否是超时，如果是就返回，否则就认为是有入队请求唤醒当前线程，但是当前线程尝试删除头结点失败了（被其他线程删除了），那么继续尝试删除头结点，再次执行循环中的内容直到超时
                start = end;
            }
        }
    }
}

ReferenceQueue是线程安全的，出队入队操作都由lock对象来保证线程安全，当用户线程和jvm线程同时访问ReferenceQueue的时候不会出现并发问题。

WeakHashMap

WeakHashMap内部同样是通过一个数组来实现存储，解决冲突的方式也是使用拉链法，weakHashMap中重新定义了Entry类来存储kv键值对，Entry的实现也是实现WeakHashMap特性的关键。

1、Entry的定义

WeakHashMap重新定义了一个entry,这个entry继承了WeakReference类并且实现了Entry接口，使用该Entry存储键值对不会产生强引用，jvm在垃圾回收的时候不会认为该引用是强引用，会正常的回收对象，Entry的定义如下

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
  V value;          //存储的value    
  final int hash;   //hash值
  Entry<K,V> next;  //拉链法解决冲突，形成单链表
        
  Entry(Object key, V value,ReferenceQueue<Object> queue, int hash, Entry<K,V> next) {
  super(key, queue);   //这里的引用对象是key，跟踪的是key对象的垃圾回收
  this.value = value;
  this.hash  = hash;
  this.next  = next;
  }
  ...
}

Entry的构造器需要传入ReferenceQueue，这个queue就可以用来监控全局的Entry被清理的情况。
2、清理操作
当对象被垃圾回收的时候，当前Map需要删除掉对应的Entry，因为Entry此时指向的对象已经被回收，所以需要找到被JVM回收的对象对应的Entry并且将Entry对象从Map中移除掉，实现方式是expungeStaleEntries方法

private void expungeStaleEntries() {
    for (Object x; (x = queue.poll()) != null; ) {
        synchronized (queue) {
            @SuppressWarnings("unchecked")
                Entry<K,V> e = (Entry<K,V>) x;
            int i = indexFor(e.hash, table.length); //从队列中拿到entry，根据entry获取entry链表在table中的索引

            Entry<K,V> prev = table[i]; //找到entry链表的头结点
            Entry<K,V> p = prev;
            while (p != null) {
                Entry<K,V> next = p.next;
                if (p == e) {
                    if (prev == e)
                        table[i] = next; //找到对应节点
                    else
                        prev.next = next;
                    e.value = null; // Help GC
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}

该方法在map中的getTable()、size()和resize()方法中被调用，每次put或是get的时候都会先执行getTable()方法，因此每次读写数据的时候都会清理掉无用的entry，所以用户不会获取到被垃圾回收的清理entry，因此，每次用户调用get方法或是size方法的时候，都会触发清理操作，所以每次返回的结果可能都不相同，因为内部的entry持有的对象已经被jvm回收。

线程安全问题

WeakHashMap作为容器本事不是线程安全的，但是在使用过程中，ReferenceQueue可能会被当前业务线程和JVM线程并发访问，ReferenceQueue是线程安全的。