Map 大家族的那点事儿 ( 5 ) :WeakHashMap

java admin 2800 0 评论

WeakHashMap是一个基于Map接口实现的散列表,实现细节与HashMap类似(都有负载因子、散列函数等等,但没有HashMap那么多优化手段),它的特殊之处在于每个key都是一个弱引用。

首先我们要明白什么是弱引用,Java将引用分为四类(从JDK1.2开始),强度依次逐渐减弱:

  • 强引用: 就是平常使用的普通引用对象,例如Object obj = new Object(),这就是一个强引用,强引用只要还存在,就不会被垃圾收集器回收。
  • 软引用: 软引用表示一个还有用但并非必需的对象,不像强引用,它还需要通过SoftReference类来间接引用目标对象(除了强引用都是如此)。被软引用关联的对象,在将要发生内存溢出异常之前,会被放入回收范围之中以进行第二次回收(如果第二次回收之后依旧没有足够的内存,那么就会抛出OOM异常)。
  • 弱引用: 同样是表示一个非必需的对象,但要比软引用的强度还要弱,需要通过WeakReference类来间接引用目标对象。被弱引用关联的对象只能存活到下一次垃圾回收发生之前,当触发垃圾回收时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象(如果这个对象还被强引用所引用,那么就不会被回收)。
  • 虚引用: 这是一种最弱的引用关系,需要通过PhantomReference类来间接引用目标对象。一个对象是否有虚引用的存在,完全不会对其生存时间构成影响,也无法通过虚引用来获得对象实例。虚引用的唯一作用就是能在这个对象被回收时收到一个系统通知(结合ReferenceQueue使用)。基于这点可以通过虚引用来实现对象的析构函数,这比使用finalize()函数是要靠谱多了。

WeakHashMap适合用来当做一个缓存来使用。假设你的缓存系统是基于强引用实现的,那么你就必须以手动(或者用一条线程来不断轮询)的方式来删除一个无效的缓存项,而基于弱引用实现的缓存项只要没被其他强引用对象关联,就会被直接放入回收队列。

需要注意的是,只有key是被弱引用关联的,而value一般都是一个强引用对象。因此,需要确保value没有关联到它的key,否则会对key的回收产生阻碍。在极端的情况下,一个value对象A引用了另一个key对象D,而与D相对应的value对象C又反过来引用了与A相对应的key对象B,这就会产生一个引用循环,导致D与B都无法被正常回收。想要解决这个问题,就只能把value也变成一个弱引用,例如m.put(key, new WeakReference(value)),弱引用之间的互相引用不会产生影响。

查找操作的实现跟HashMap相比简单了许多,只要读懂了HashMap,基本都能看懂,源码如下:

/**
 * Value representing null keys inside tables.
 */
private static final Object NULL_KEY = new Object();
/**
 * Use NULL_KEY for key if it is null.
 */
private static Object maskNull(Object key) {
return (key == null) ? NULL_KEY : key;
}
/**
 * Returns index for hash code h.
 */
private static int indexFor(int h, int length) {
return h & (length-1);
}
public V get(Object key) {
// WeakHashMap允许null key与null value
// null 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) {
if (e.hash == h && eq(k, e.get()))


return e.value;
e = e.next;
}
return null;
}

尽管key是一个弱引用,但仍需手动地回收那些已经无效的Entry。这个操作会在getTable()函数中执行,不管是查找、添加还是删除,都需要调用getTable()来获得buckets数组,所以这是种防止内存泄漏的被动保护措施。

/**
 * The table, resized as necessary. Length MUST Always be a power of two.
 */
Entry<K,V>[] table;
/**
 * Reference queue for cleared WeakEntries
 */
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
/**
 * Expunges stale entries from the table.
 */
private void expungeStaleEntries() {
// 遍历ReferenceQueue,然后清理table中无效的Entry
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;


}
}
}
}
/**
 * Returns the table after first expunging stale entries.
 */
private Entry<K,V>[] getTable() {
expungeStaleEntries();
return table;
}

然后是插入操作与删除操作,实现都比较简单:

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

我们并没有在put()函数中发现key被转换成弱引用,这是怎么回事?key只有在第一次被放入buckets数组时才需要转换成弱引用,也就是new Entry<>(k, value, queue, h, e),WeakHashMap的Entry实现其实就是WeakReference的子类。

/**
 * The entries in this hash table extend WeakReference, using its main ref
 * field as the key.
 */
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;
}
@SuppressWarnings("unchecked")
public K getKey() {
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();
}
}

有关使用WeakReference的一个典型案例是ThreadLocal,感兴趣的读者可以参考我之前写的博客聊一聊Spring中的线程安全性

转载请注明: 飞嗨_分享互联网 » Map 大家族的那点事儿 ( 5 ) :WeakHashMap

赞 (0) or 分享 (0)
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽

高效,专业,符合SEO

联系我们