Map(五)：WeakHashMap

WeakHashMap是一个基于Map接口实现的散列表，实现细节与HashMap类似（都有负载因子、散列函数等等，但没有HashMap那么多优化手段），它的特殊之处在于每个key都是一个弱引用。

首先我们要明白什么是弱引用，Java将引用分为四类（从JDK1.2开始），强度依次逐渐减弱：

• 强引用： 就是平常使用的普通引用对象，例如Object obj = new Object()，这就是一个强引用，强引用只要还存在，就不会被垃圾收集器回收。
• 软引用： 软引用表示一个还有用但并非必需的对象，不像强引用，它还需要通过SoftReference类来间接引用目标对象（除了强引用都是如此）。被软引用关联的对象，在将要发生内存溢出异常之前，会被放入回收范围之中以进行第二次回收（如果第二次回收之后依旧没有足够的内存，那么就会抛出OOM异常）。
• 弱引用： 同样是表示一个非必需的对象，但要比软引用的强度还要弱，需要通过WeakReference类来间接引用目标对象。被弱引用关联的对象只能存活到下一次垃圾回收发生之前，当触发垃圾回收时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象（如果这个对象还被强引用所引用，那么就不会被回收）。
• 虚引用： 这是一种最弱的引用关系，需要通过PhantomReference类来间接引用目标对象。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获得对象实例。虚引用的唯一作用就是能在这个对象被回收时收到一个系统通知（结合ReferenceQueue使用）。基于这点可以通过虚引用来实现对象的析构函数，这比使用finalize()函数是要靠谱多了。

WeakHashMap适合用来当做一个缓存来使用。假设你的缓存系统是基于强引用实现的，那么你就必须以手动（或者用一条线程来不断轮询）的方式来删除一个无效的缓存项，而基于弱引用实现的缓存项只要没被其他强引用对象关联，就会被直接放入回收队列。

需要注意的是，只有key是被弱引用关联的，而value一般都是一个强引用对象。因此，需要确保value没有关联到它的key，否则会对key的回收产生阻碍。在极端的情况下，一个value对象A引用了另一个key对象D，而与D相对应的value对象C又反过来引用了与A相对应的key对象B，这就会产生一个引用循环，导致D与B都无法被正常回收。想要解决这个问题，就只能把value也变成一个弱引用，例如m.put(key, new WeakReference(value))，弱引用之间的互相引用不会产生影响。

查找操作的实现跟HashMap相比简单了许多，只要读懂了HashMap，基本都能看懂，源码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

/**  * Value representing null keys inside tables.  */ private static final Object NULL_KEY = new Object(); /**  * Use NULL_KEY for key if it is null.  */ private static Object maskNull(Object key) {     return (key == null) ? NULL_KEY : key; } /**  * Returns index for hash code h.  */ private static int indexFor(int h, int length) {     return h & (length-1); } public V get(Object key) {     // WeakHashMap允许null key与null value     // null key会被替换为一个虚拟值     Object k = maskNull(key);     int h = hash(k);     Entry<K,V>[] tab = getTable();     int index = indexFor(h, tab.length);     Entry<K,V> e = tab[index];     // 遍历链表     while (e != null) {         if (e.hash == h && eq(k, e.get()))             return e.value;         e = e.next;     }     return null; }

尽管key是一个弱引用，但仍需手动地回收那些已经无效的Entry。这个操作会在getTable()函数中执行，不管是查找、添加还是删除，都需要调用getTable()来获得buckets数组，所以这是种防止内存泄漏的被动保护措施。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

/**  * The table, resized as necessary. Length MUST Always be a power of two.  */ Entry<K,V>[] table; /**  * Reference queue for cleared WeakEntries  */ private final ReferenceQueue<Object> queue = new ReferenceQueue<>(); /**  * Expunges stale entries from the table.  */ private void expungeStaleEntries() {     // 遍历ReferenceQueue，然后清理table中无效的Entry     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<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;                     else                         prev.next = next;                     // Must not null out e.next;                     // stale entries may be in use by a HashIterator                     e.value = null; // Help GC                     size--;                     break;                 }                 prev = p;                 p = next;             }         }     } } /**  * Returns the table after first expunging stale entries.  */ private Entry<K,V>[] getTable() {     expungeStaleEntries();     return table; }

然后是插入操作与删除操作，实现都比较简单：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

public V put(K key, V value) {     Object k = maskNull(key);     int h = hash(k);     Entry<K,V>[] tab = getTable();     int i = indexFor(h, tab.length);     for (Entry<K,V> e = tab[i]; e != null; e = e.next) {         if (h == e.hash && eq(k, e.get())) {             V oldValue = e.value;             if (value != oldValue)                 e.value = value;             return oldValue;         }     }     modCount++;     Entry<K,V> e = tab[i];     // e被连接在new Entry的后面     tab[i] = new Entry<>(k, value, queue, h, e);     if (++size >= threshold)         resize(tab.length * 2);     return null; } public V remove(Object key) {     Object k = maskNull(key);     int h = hash(k);     Entry<K,V>[] tab = getTable();     int i = indexFor(h, tab.length);     Entry<K,V> prev = tab[i];     Entry<K,V> e = prev;     while (e != null) {         Entry<K,V> next = e.next;         if (h == e.hash && eq(k, e.get())) {             modCount++;             size--;             if (prev == e)                 tab[i] = next;             else                 prev.next = next;             return e.value;         }         prev = e;         e = next;     }     return null; }

我们并没有在put()函数中发现key被转换成弱引用，这是怎么回事？key只有在第一次被放入buckets数组时才需要转换成弱引用，也就是new Entry<>(k, value, queue, h, e)，WeakHashMap的Entry实现其实就是WeakReference的子类。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

/**  * The entries in this hash table extend WeakReference, using its main ref  * field as the key.  */ private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {     V value;     final int hash;     Entry<K,V> next;     /**      * Creates new entry.      */     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;     }     @SuppressWarnings("unchecked")     public K getKey() {         return (K) WeakHashMap.unmaskNull(get());     }     public V getValue() {         return value;     }     public V setValue(V newValue) {         V oldValue = value;         value = newValue;         return oldValue;     }     public boolean equals(Object o) {         if (!(o instanceof Map.Entry))             return false;         Map.Entry<?,?> e = (Map.Entry<?,?>)o;         K k1 = getKey();         Object k2 = e.getKey();         if (k1 == k2 || (k1 != null && k1.equals(k2))) {             V v1 = getValue();             Object v2 = e.getValue();             if (v1 == v2 || (v1 != null && v1.equals(v2)))                 return true;         }         return false;     }     public int hashCode() {         K k = getKey();         V v = getValue();         return Objects.hashCode(k) ^ Objects.hashCode(v);     }     public String toString() {         return getKey() + "=" + getValue();     } }

有关使用WeakReference的一个典型案例是ThreadLocal，感兴趣的读者可以参考我之前写的博客聊一聊Spring中的线程安全性。