WeakHashMap 解析

WeakHashMap

public class WeakHashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V> {

 ......
    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
 ......

}

WeakHashMap和HashMap一样key和value的值都可以为null，并且也是无序的。但是HashMap的null是存在table[0]中的，这是固定的，并且null的hash为0，而在WeakHashMap中的null却没有存入table[0]中。 这是因为WeakHashMap对null值进行了包装：NULL_KEY

Entry 代码

    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;
        }

    ......

    private void expungeStaleEntries() {
    
        // 遍历 ReferenceQueue 的 WeakReference 对象 Key 已经被GC回收的
        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;
                    // 找到与 queue 中 WeakReference 对象对应的节点 
                    if (p == e) {
                        // 判断 p 是不是单链表的首节点
                        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;
                }
            }
        }
    }

expungeStaleEntries调用关系

在 WeakHashMap 中几乎所有的操作（put，remove，get，size）都会涉及到消除操作，这也正体现了它的 weak。

NULL_KEY

上面提到了 WeakHashMap 的成员变量 NULL_KEY，当 key = null 时，会被其代替。

    private static Object maskNull(Object key) {
        return (key == null) ? NULL_KEY : key;
    }

key 是弱引用，在其被 GC 回收后，对应的节点就会从（key-value）变成（null-value）；
当要新增一个 key = null 的节点时，即 put（null，key）为了避免其被当成无用节点。null 会被
NULL_KEY 代替，变成（NULL_KEY，key）以此来区分。

实例

public class AnalyzeWeakHashMap {
    public static void main(String[] args) throws Exception {
//        test1();
//        test2();

//        test3();
//
        test4();


    }

    private static void test4() {
        List<WeakHashMap<byte[][], byte[][]>> maps = new ArrayList<WeakHashMap<byte[][], byte[][]>>();
        for (int i = 0;; i++) {
            WeakHashMap<byte[][], byte[][]> d = new WeakHashMap<byte[][], byte[][]>();
            d.put(new byte[10000][10000], new byte[10000][10000]);
            maps.add(d);
            System.gc();
            // 关键 -> 区别：
//            System.err.print(i+"，");

            System.err.println(  "size = " + d.size());

            // 输出结果：
            // size = 0
            // ...
        }
    }

    private static void test3() {
        List<WeakHashMap<byte[][], byte[][]>> maps = new ArrayList<WeakHashMap<byte[][], byte[][]>>();
        for (int i = 0;; i++) {
            WeakHashMap<byte[][], byte[][]> d = new WeakHashMap<byte[][], byte[][]>();
            d.put(new byte[10000][10000], new byte[10000][10000]);
            maps.add(d);
            System.gc();
            System.err.print(i+"，");

            // 输出结果：
            // 0，1，2，3，4，5，6，7，8，9，10，
            // Exception in thread "main" java.lang.OutOfMemoryError: Java heap space at Test3.main(Test3.java:10)
        }
    }

    private static void test2() throws InterruptedException {
        WeakHashMap<Object, String> wmap = new WeakHashMap<Object, String>();
        wmap.put(new Object(), "a");
        System.gc();
        Thread.sleep(100);
        System.out.println(wmap.size());
        // 输出结果：0
    }

    private static void test1() throws InterruptedException {
        WeakHashMap<Object, String> wmap = new WeakHashMap<Object, String>();
        wmap.put(null, "a");
        System.gc();
        Thread.sleep(100);
        System.out.println(wmap.size());
        // 输出结果：1
    }

}

实例 三，在程序运行不久后就 OOF 了。实例 四 ，则能一直运行下去。观察代码，发现它们的区别仅仅是最后调用了 size 方法。原因就在这里，size 方法会调用 expungeStaleEntries 清除无用节点，防止内存不断增加。