WeakHashMap分析

WeakHashMap是基于弱键的HashMap，什么是弱键，如果不懂，可以看我前面的博客分析。
先用例子演示下WeakHashMap的使用，为了展示效果我们设置vm参数：-XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xms10m -Xmx10m，不懂的可以百度下，eclipse如何设置jvm参数。

public class WeakHashMapTest {

     static class Value {
           private byte[] buf = new byte[1024 * 1024];
     }
     static class Key {
           @Override
           protected void finalize() throws Throwable {
                System.out.println("最后的清除通知 --》" + this);
           }
     }

     public static void main(String[] args) {
           WeakHashMap<Key, Value> map = new WeakHashMap<>();
           for(int i = 0; i < 10; i++) {
                Key key = new Key();
                map.put(key, new Value());
           }
           for(Map.Entry<Key, Value> each : map.entrySet()) {
                     System.out.println(each.getKey() + "__" + each.getValue());
           }
     }
}

运行程序：

0.076: [GC [PSYoungGen: 1800K->504K(3072K)] 1800K->1704K(10240K), 0.0013254 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
0.078: [GC [PSYoungGen: 2639K->496K(3072K)] 3839K->3804K(10240K), 0.0010971 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
0.079: [GC [PSYoungGen: 2619K->496K(3072K)] 5927K->5908K(10240K), 0.0016980 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
0.081: [Full GC [PSYoungGen: 496K->0K(3072K)] [ParOldGen: 5412K->2587K(7168K)] 5908K->2587K(10240K) [PSPermGen: 2463K->2462K(21504K)], 0.0097679 secs] [Times: user=0.01 sys=0.00, real=0.02 secs]
0.091: [GC [PSYoungGen: 2089K->224K(3072K)] 4677K->4859K(10240K), 0.0010216 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
0.093: [Full GC [PSYoungGen: 224K->0K(3072K)] [ParOldGen: 4635K->2587K(7168K)] 4859K->2587K(10240K) [PSPermGen: 2462K->2462K(21504K)], 0.0105158 secs] [Times: user=0.02 sys=0.00, real=0.02 secs]
0.104: [GC [PSYoungGen: 2075K->192K(3072K)] 4663K->4827K(10240K), 0.0007538 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
0.104: [Full GC [PSYoungGen: 192K->0K(3072K)] [ParOldGen: 4635K->2588K(7168K)] 4827K->2588K(10240K) [PSPermGen: 2462K->2462K(21504K)], 0.0083117 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@2a36bb87
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@2ce1b3b3
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@6e70c242
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@7d2f117
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@2891fa78
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@5511e28
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@4fd281f1
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@1cf38f09
最后的清除通知 --》com.esy.rice.tool.simple.WeakHashMapTest$Key@3dffb2eb
com.esy.rice.tool.simple.WeakHashMapTest$Key@30a14e84__com.esy.rice.tool.simple.WeakHashMapTest$Value@57f68d7c

我们发现最后能够从WeakHashMap 取出的只有一个对象，而其他的对象都消失了，这是怎么一回事呢？
我们先简单的讲下垃圾回收的过程，对象的回收并不是只经过一次对象可达性判定就被回收的，回收动作会经过最后的确认，当finalize的调用后，对象任然没有被引用，就会被接下来的gc回收掉，也就是说finalize是对象最后自救的方法。从上面的垃圾回收打印信息可以看到，经过了几次垃圾回收后，整个系统的堆确实有被回收，已使用的堆缩小了。
但是有个疑问？照理说放入map的对象应该是具有强引用的才对啊。那至于为什么消失？又是怎么消失的？就需要从源码进行研究，首先看看WeakHashMap每个节点的构造，看下面代码。

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        V value;
        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;
        }
}

发现节点是继承自WeakReference（弱引用），而弱引用的作用就是下一次垃圾回收，会把包装的对象进行回收。我们看到构造函数中，entry的key进行了引用包装，那么key就会在下一次垃圾回收到来时，进行回收处理，也就是先进入ReferenceQueue队列。
但是key的回收并不会回收整个Entry对象啊，对象的引用链还在，还是强引用，那么WeakReference到底是如何进行Entry回收的呢，又是何时进行？
我们找找源码，会发现，每一次获取hashMap中的元素数组，也就是table时，会将即将被回收的key，也就是已经进入ReferenceQueue队列的key对应的Entry对象断开链接，让entry对象处于不可达状态，具体也就是下面的代码。

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

每一次get和put操作都会进行expungeStaleEntries清除操作，断开Entry的引用，然后让垃圾回收器可以进行回收，也就是说，key的清除并不会立即清除整个Entry对象，而是等下次垃圾回收到来时才会被清除。
从上面的分析可以看出，WeakHashMap很适合做key-value的本地缓存，尤其是短时间内的并发访问，可以有很高的命中率，不用了的缓存也会自动的被清除。
本人就用过，在shiro+redis进行权限会话管理时，每次会话都会有将近10次的redis请求，我就用了WeakHashMap做了本地缓存。