Java之WeakHashMap实现原理

WeakHashMap的存储结构类似于HashMap，不过是以弱键实现的基于哈希表的 Map；

在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条目；WeakHashMap中的每个key对象保存了实际对象的弱引用，当回收了该key所对应的实际对象后，WeakHashMap会自动删除该key所对应的键值对;
以下代码是WeakHashmap中的静态类部分源码用来保存健值对，它继承了WeakReference；

private static final class Entry<K, V> extends WeakReference<K> implements Map.Entry<K, V> {
        final int hash;
        boolean isNull;
        V value;
        Entry<K, V> next;
        interface Type<R, K, V> {
            R get(Map.Entry<K, V> entry);
        }
        Entry(K key, V object, ReferenceQueue<K> queue) {
            super(key, queue);
            isNull = key == null;
            hash = isNull ? 0 : Collections.secondaryHash(key);
            value = object;
        }
        ......
}

应用场景

WeekHashMap 的这个特点特别适用于需要缓存的场景 。在缓存场景下，由于内存是有限的，不能缓存所有对象；对象缓存命中可以提高系统效率，但缓存MISS也不会造成错误，因为可以通过计算重新得到；（图片的三级缓存）

代码示例

public class WeakHashMapTest {  
    public static void main(String[] args) {  
        WeakHashMap w= new WeakHashMap();  
        //三个key-value中的key 都是匿名对象，没有强引用指向该实际对象  
        w.put(new String("语文"),new String("优秀"));  
        w.put(new String("数学"), new String("及格"));  
        w.put(new String("英语"), new String("中等"));  
        //增加一个字符串的强引用  
        w.put("java", new String("特别优秀"));  
        System.out.println(w);  
        //通知垃圾回收机制来进行回收  
        System.gc();  
        System.runFinalization();  
        //再次输出w
        System.out.println("第二次输出:"+w);  
    }    
} 

输出结果：
第一次输出w:{java=特别优秀, 数学=及格, 英语=中等, 语文=优秀}
第二次输出w:{java=特别优秀}
所以在最开始的代码中WeakHashMap<String, Integer> weakMap = new WeakHashMap<String, Integer>(); weakMap没有强引用指引，所以在执行System.gc()后weakMap被系统GC收回；

当回收了该key所对应的实际对象后，WeakHashMap是如何删除该key所对应的键值对；

queue保存的是“已被GC清除”的“弱引用的键”， 弱引用和ReferenceQueue 是联合使用的：如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中；（jdk1.8看weakHashmap的pull()方法）

private final ReferenceQueue<K> queue = new ReferenceQueue<K>();

// 清空table中无用键值对。原理如下：
// (01) 当WeakHashMap中某个“弱引用的key”由于没有再被引用而被GC收回时，
    //   被回收的“该弱引用key”会被添加到"ReferenceQueue(queue)"中。

// (02) 当我们执行expungeStaleEntries时，
    //   就遍历"ReferenceQueue(queue)"中的所有key
    //   然后就在“WeakReference的table”中删除与“ReferenceQueue(queue)中key”对应的键值对

private void expungeStaleEntries() {
  Entry<K,V> e;
  while ( (e = (Entry<K,V>) queue.poll()) != null) {
    int h = e.hash;
    int i = indexFor(h, 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;
          e.next = null;  // Help GC
          e.value = null; //  "   "
          size--;
          break;
        }
        prev = p;
        p = next;
    }
  }
}

对null键的特殊处理

// 键为null的mask值。
// 因为WeakReference中允许“null的key”，若直接插入“null的key”，将其当作弱引用时，会被删除。
// 因此，这里对于“key为null”的清空，都统一替换为“key为NULL_KEY”，“NULL_KEY”是“静态的final常量”。

private static final Object NULL_KEY = new Object();

// 对“null的key”进行特殊处理
private static Object maskNull(Object key) {
    return (key == null ? NULL_KEY : key);
}

// 还原对“null的key”的特殊处理
private static <K> K unmaskNull(Object key) {
    return (K) (key == NULL_KEY ? null : key);
}

引用类别

• 1.强引用(StrongReference)：GC不会回收强引用，即使内存不足的情况下也不会，宁可OOM；
• 2.软引用(SoftReference)：只有当内存不够的时候才进行回收，而在内存足够的时候，通常不被回收；另外，引用对象还能保证在 Java 抛出 OutOfMemoryError 之前，被设置为null；
• 3.弱引用(WeakReference)：一定会被回收，若对象的引用关系复杂，则可能需要多次回收才能达到目的；
• 4.虚引用(PhantomReference)：PhantomReference 对象执行完了 finalize 方法后，成为 Unreachable Objects。但还未被回收，在此时，可以辅助 finalize 进行一些后期的回收工作；（第四种不常用到）