《java集合》--WeakHashMap

《java集合》–WeakHashMap

说明：此文章基于jdk1.8

参考：Java WeakHashMap 源码解析

简介

WeakHashMap同HashMap的数据结构一样，它的主要目的是为了优化jvm的垃圾回收，通过弱引用让垃圾回收器更加智能的回收无用的对象。

弱引用（WeakReference）。我们都知道Java中内存是通过GC自动管理的，GC会在程序运行过程中自动判断哪些对象是可以被回收的，并在合适的时机进行内存释放。GC判断某个对象是否可被回收的依据是，是否有有效的引用指向该对象。如果没有有效引用指向该对象（基本意味着不存在访问该对象的方式），那么该对象就是可回收的。这里的“有效引用”并不包括弱引用。也就是说，虽然弱引用可以用来访问对象，但进行垃圾回收时弱引用并不会被考虑在内，仅有弱引用指向的对象仍然会被GC回收。

当弱引用指向的对象只能通过弱引用（没有强引用或弱引用）访问时，GC会清理掉该对象，之后，引用对象会被放到ReferenceQueue中。也就是说如果WeakHashMap中的key值没有其它引用引用key的话，那么gc将会回收key对应的对象，然后在对WeakHashMap进行增删改查时遍历队列中的key对象，移除map中key对应的entry对象，gc回收

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

数据结构

跟hashMap的存储结构一样

基本属性

• private final ReferenceQueue queue = new ReferenceQueue<>(); 当gc回收key对象时，会将key对象放入quene中，然后在对WeakHashMap进行增删改查时遍历队列中的key对象，移除map中key对应的entry对象，gc回收
• 其它属性同HashMap一样

构造器

 public WeakHashMap(int initialCapacity, float loadFactor) {
   if (initialCapacity < 0)
     throw new IllegalArgumentException("Illegal Initial Capacity: "+
                                        initialCapacity);
   if (initialCapacity > MAXIMUM_CAPACITY)
     initialCapacity = MAXIMUM_CAPACITY;

   if (loadFactor <= 0 || Float.isNaN(loadFactor))
     throw new IllegalArgumentException("Illegal Load factor: "+
                                        loadFactor);
   int capacity = 1;
   while (capacity < initialCapacity)
     capacity <<= 1;
   table = newTable(capacity);
   this.loadFactor = loadFactor;
   threshold = (int)(capacity * loadFactor);
 }
 private Entry<K,V>[] newTable(int n) {
   return (Entry<K,V>[]) new Entry<?,?>[n];
 }

存储的Entry

WeakHashMap中的key存储的时候使用的是弱引用，当没有其它指针引用该key对象的时候，gc会回收key对象，之后引用的key对象会被放到ReferenceQueue中。

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传给了父类WeakReference，说明key为弱引用（没有显式的 this.key = key）,所有如果key只有通过弱引用访问时，key会被 GC 清理掉,同时该key所代表的Entry会进入queue中，等待被处理
    super(key, queue);
    //value为强引用（有显式的 this.value = value ），但这并不影响
    this.value = value;
    this.hash  = hash;
    this.next  = next;
  }

  @SuppressWarnings("unchecked")
  public K getKey() {
    //get():return this.referent;
    ////在获取key时需要unmaskNull，因为对于null的key，是用WeakHashMap的内部成员属性来表示的
    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();
  }
}

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

在对WeakHashMap进行增删改查时，都调用了expungeStaleEntries方法

private void expungeStaleEntries() {
  //获取已被回收key对象的队列循环gc回收对应的entry对象
  for (Object x; (x = queue.poll()) != null; ) {
    //加同步锁
    synchronized (queue) {
      @SuppressWarnings("unchecked")
      Entry<K,V> e = (Entry<K,V>) x;
      //根据key值获取entry所在table的下标
      int i = indexFor(e.hash, table.length);

      Entry<K,V> prev = table[i];
      Entry<K,V> p = prev;
      // while 循环遍历冲突链
      while (p != null) {
        Entry<K,V> next = p.next;
        if (p == e) {
          if (prev == e)
            table[i] = next;
          else
            prev.next = next;
         //将entry的value置为空，让gc回收
          e.value = null; // Help GC
          size--;
          break;
        }
        prev = p;
        p = next;
      }
    }
  }
}