【集合系列】- 深刻浅出的分析 WeakHashMap

1、摘要

在集合系列的第一章，我们了解到，Map 的实现类有 HashMap、LinkedHashMap、TreeMap、IdentityHashMap、WeakHashMap、Hashtable、Properties 等等。

本文主要从数据结构和算法层面，探讨 WeakHashMap 的实现。

2、简介

刚刚我们也介绍了，在 Map 家族中，WeakHashMap 是一个很特殊的成员，它的特殊之处在于 WeakHashMap 里的元素可能会被 GC 自动删除，即便程序员没有显示调用 remove() 或者 clear() 方法。

换言之，当向 WeakHashMap 中添加元素的时候，再次遍历获取元素，可能发现它已经不见了，咱们来看看下面这个例子。

public static void main(String[] args) {
        Map weakHashMap = new WeakHashMap();
        
        //向weakHashMap中添加4个元素
        for (int i = 0; i < 3; i++) {
            weakHashMap.put("key-"+i, "value-"+ i);
        }
        //输出添加的元素
        System.out.println("数组长度："+weakHashMap.size() + "，输出结果：" + weakHashMap);
        
        //主动触发一次GC
        System.gc();
        
        //再输出添加的元素
        System.out.println("数组长度："+weakHashMap.size() + "，输出结果：" + weakHashMap);
    }

输出结果：

数组长度：3，输出结果：{key-2=value-2, key-1=value-1, key-0=value-0}
数组长度：3，输出结果：{}

当主动调用 GC 回收器的时候，再次查询 WeakHashMap 里面的数据的时候，内容为空。

更直观的说，当使用 WeakHashMap 时，即便没有显式的添加或删除任何元素，也可能发生以下状况：

• 调用两次 size() 方法返回不一样的值；
• 两次调用 isEmpty() 方法，第一次返回 false，第二次返回 true；
• 两次调用 containsKey() 方法，第一次返回 true，第二次返回 false，尽管两次使用的是同一个key；
• 两次调用 get() 方法，第一次返回一个 value，第二次返回 null，尽管两次使用的是同一个对象。

要明白 WeekHashMap 的工做原理，还须要引入一个概念：弱引用。

咱们都知道 Java 中内存是经过 GC 自动管理的，GC 会在程序运行过程当中自动判断哪些对象是能够被回收的，并在合适的时机进行内存释放。

GC 判断某个对象是否可被回收的依据是，是否有有效的引用指向该对象。若是没有有效引用指向该对象（基本意味着不存在访问该对象的方式），那么该对象就是可回收的。

2.一、对象引用介绍

从 JDK1.2 版本开始，把对象的引用分为四种级别，从而使程序更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

用表格整理以后，各个引用类型的区别以下：

2.1.一、强引用

强引用是使用最广泛的引用，例如，咱们建立一个对象：

//强引用类型
Object object=new Object();

若是一个对象具备强引用，那垃圾回收器毫不会回收它。当内存空间不足， Java 虚拟机宁愿抛出 OutOfMemoryError 错误，使程序异常终止，也不会靠随意回收具备强引用的对象来解决内存不足的问题。

若是不使用时，要手动经过以下方式来弱化引用，以下：

//将对象设置为null，帮助垃圾收集器回收此对象
object=null;

这个时候，GC 认为该对象不存在引用，就能够回收这个对象，具体何时收集这要取决于 GC 的算法。

2.1.二、软引用

被SoftReference指向的对象，属于软引用，以下：

String str=new String("abc");

//软引用
SoftReference<String> softRef=new SoftReference<String>(str);

若是一个对象只具备软引用，则内存空间足够，垃圾回收器就不会回收它；若是内存空间不足了，就会进入垃圾回收器，Java 虚拟机就会把这个软引用加入到与之关联的引用队列中，GC 进行回收处理。只要垃圾回收器没有回收它，该对象就能够被程序使用。

当内存不足时，等价于：

If(JVM.内存不足()) {
   str = null;  // 转换为软引用
   System.gc(); // 垃圾回收器进行回收
}

软引用的这种特性，比较适合内存敏感的场景，作高速缓存。在某些场景下，好比，系统内存不是很足的状况下，可使用软引用，GC 会自动回收，再次获取对象的时候，能够对缓存对象进行重建，而又不影响使用。好比：

//建立一个缓存内容cache
String cache = new String("abc");

//进行软引用处理
SoftReference<String> softRef=new SoftReference<String>(cache);

//判断是否被垃圾回收器回收
if(softRef.get()!=null){
    //尚未被回收器回收，直接获取
    cache = (String) softRef.get();
}else{
    //因为内存吃紧，因此对软引用的对象回收了
    //重建缓存对象
    cache = new String("abc");
    SoftReference<String> softRef = new SoftReference<String>(cache);
}

2.1.三、弱引用

被WeakReference指向的对象，属于弱引用，以下：

String str=new String("abc");

//弱引用
WeakReference<String> abcWeakRef = new WeakReference<String>(str);

弱引用与软引用的区别在于：具备弱引用的对象拥有更短暂的生命周期。

在垃圾回收器线程扫描它所管辖的内存区域的过程当中，一旦发现了只具备弱引用的对象，无论当前内存空间足够与否，都会回收它的内存。不过，因为垃圾回收器是一个优先级很低的线程，所以不必定会很快发现那些只具备弱引用的对象。

当垃圾回收器进行扫描回收时，等价于：

str = null;
System.gc();

若是这个对象是偶尔的使用，而且但愿在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么你应该用 WeakReference 来记住此对象。

一样的，弱引用对象进入垃圾回收器，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中，GC 进行回收处理。

2.1.四、虚引用

被PhantomReference指向的对象，属于虚引用。

虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列联合使用，以下：

String str=new String("abc");

//建立引用队列
ReferenceQueue<String> queue = new ReferenceQueue<String>();

//建立虚引用
PhantomReference<String> phantomReference = new PhantomReference<String>(str, queue);

虚引用，顾名思义，就是形同虚设，与其余几种引用都不一样，虚引用并不会决定对象的生命周期。若是一个对象仅持有虚引用，那么它就和没有任何引用同样，在任什么时候候均可能被垃圾回收器回收。

当垃圾回收器准备回收一个对象时，若是发现它是虚引用，就会在回收对象的内存以前，把这个虚引用加入到与之关联的引用队列中，GC 进行回收处理。

2.1.五、总结

Java 4中引用的级别由高到低依次为：强引用 > 软引用 > 弱引用 > 虚引用。

用一张图来看一下他们之间在垃圾回收时的区别：

再次回到本文要讲的 WeakHashMap！

WeakHashMap 内部是经过弱引用来管理 entry 的，弱引用的特性对应到 WeakHashMap 上意味着什么呢？将一对 key, value 放入到 WeakHashMap 里，随时都有可能被 GC 回收。

下面，我们一块儿来看看 WeakHashMap 的具体实现。

3、经常使用方法介绍

3.一、put方法

put 方法是将指定的 key, value 对添加到 map 里，存储结构相似于 HashMap；
不一样的是，WeakHashMap 中存储的 Entry 继承自 WeakReference，实现了弱引用。

打开源码以下：

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];
        tab[i] = new Entry<>(k, value, queue, h, e);
        if (++size >= threshold)
            resize(tab.length * 2);
        return null;
}

WeakHashMap 中存储的 Entry，源码以下：

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        V value;
        final int hash;
        Entry<K,V> next;

        Entry(Object key, V value,
              ReferenceQueue<Object> queue,
              int hash, Entry<K,V> next) {
              
            //将key进行弱引用处理
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }
        ......
}

须要注意的是，Entry 中super(key, queue)，传入的是key，所以key才是进行弱引用的，value是直接强引用关联在this.value中，System.gc()时，对key进行了回收，而value依然保持。

那value是什么时候被清除的呢？

阅读源码，能够看到，调用getTable()函数，对调用expungeStaleEntries()函数，该方法对 jvm 要回收的的 entry(quene 中) 进行遍历，并将 entry 的 value 设置为空，进行内存回收。

private Entry<K,V>[] getTable() {
        expungeStaleEntries();
        return table;
}

expungeStaleEntries()函数，源码以下：

private void expungeStaleEntries() {
        for (Object x; (x = queue.poll()) != null; ) {
            synchronized (queue) {
                    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;
                        //将value设置为null，方便GC回收
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
}

因此效果是 key 在 GC 的时候被清除，value 在 key 清除后，访问数组内容的时候进行清除！

3.二、get方法

get 方法根据指定的 key 值返回对应的 value。

源码以下：

public V get(Object 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) {
            //经过key，进行hash值和equals判断
            if (e.hash == h && eq(k, e.get()))
                return e.value;
            e = e.next;
        }
        return null;
}

一样的，get 方法在判断对象以前，也调用了getTable()函数，同时，也调用了expungeStaleEntries()函数，因此，可能经过 key 获取元素的时候，获得空值；若是 key 没有被 GC 回收，那么就返回对应的 value。

3.三、remove方法

remove 的做用是经过 key 删除对应的元素。

源码以下：

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;
        
        //循环链表，经过key，进行hash值和equals判断
        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;
}

一样的，remove 方法在判断对象以前，也调用了getTable()函数，同时，也调用了expungeStaleEntries()函数，因此，可能经过 key 获取元素的时候，可能被垃圾回收器回收，获得空值。

4、总结

WeakHashMap 跟普通的 HashMap 不一样，在存储数据时，key被设置为弱引用类型，而弱引用类型在 java 中，可能随时被 jvm 的 gc 回收，因此再次经过获取对象时，可能获得空值，而value是在访问数组内容的时候，进行清除。

可能不少人以为这样作很奇葩，其实否则，WeekHashMap 的这个特色特别适用于须要缓存的场景。

在缓存场景下，因为系统内存是有限的，不能缓存全部对象，可使用 WeekHashMap 进行缓存对象，即便缓存丢失，也能够经过从新计算获得，不会形成系统错误。

5、参考

一、JDK1.7&JDK1.8 源码

二、知乎 - CarpenterLee - 浅谈WeakHashMap

三、csdn - Vander丶 - Java四种引用

四、csdn - java-er - Java四种引用

做者：炸鸡可乐
出处：www.pzblog.cn