一、概述
- WeekHashMap区别于HashMap，在于key值都为弱引用。
- Java将引用分为四类，强度依次逐渐减弱：
- 强引用： 就是平常使用的普通引用对象，例如Object obj = new Object()，这就是一个强引用，强引用只要还存在，就不会被垃圾收集器回收。
- 软引用： 通过SoftReference类来间接引用目标对象。软引用表示一个还有用但并非必需的对象。被软引用关联的对象，在将要发生内存溢出异常之前，会被放入回收范围之中以进行第二次回收（如果第二次回收之后依旧没有足够的内存，那么就会抛出OOM异常），也就是说内存不够时，回收SoftReference引用的对象。
- 弱引用： 通过WeakReference类来间接引用目标对象。弱引用表示一个非必需的对象，但要比软引用的强度还要弱。被弱引用关联的对象只能存活到下一次垃圾回收发生之前，当触发垃圾回收时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象（如果这个对象还被强引用所引用，那么就不会被回收）。
- 虚引用： 通过PhantomReference类来间接引用目标对象。虚引用是一种最弱的引用关系，一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获得对象实例。虚引用的唯一作用就是能在这个对象被回收时收到一个系统通知（结合ReferenceQueue使用）。基于这点可以通过虚引用来实现对象的析构函数，这比使用finalize()函数是要靠谱多了。
二、用途
- WeekHashMap适用于当缓存来用，基于弱引用的缓存项，会在内存不足时，被GC回收。
- key是弱引用，value一般为强引用，如果发生引用循环，那么会对key回收发生阻碍。这种情况下，只能将value指定为WeekReference引用。
三、分析
1.buckets数组
Entry<K,V>[] table;
private Entry<K,V>[] newTable(int n) {
return (Entry<K,V>[]) new Entry<?,?>[n];
}2. get函数
// 空值key
private static final Object NULL_KEY = new Object();
private static Object maskNull(Object key) {
return (key == null) ? NULL_KEY : key;
}
final int hash(Object k) {
int h = k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
// 通过HashCode和容量计算bucket位置
private static int indexFor(int h, int length) {
return h & (length-1);
}
public V get(Object key) {
// 遮盖key为null
Object k = maskNull(key);
// 计算key的hashcode
int h = hash(k);
// 获取bucket数组
Entry<K,V>[] tab = getTable();
// 获取bucket索引位置
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;
}3.getTable()函数
尽管key是一个弱引用，但仍需手动地回收那些已经无效的Entry。这个操作会在getTable()函数中执行，不管是查找、添加还是删除，都需要调用getTable()来获得buckets数组，所以这是种防止内存泄漏的被动保护措施。
// 需要回收的WeekEntry队列
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
// 删除不需要的entry
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);
// 找到bucket链表
Entry<K,V> prev = table[i];
Entry<K,V> p = prev;
// 如果链表不为空
while (p != null) {
// 获取下一个entry
Entry<K,V> next = p.next;
if (p == e) { // 如果当前entry为x
if (prev == e) // 如果链表首元素是x
table[i] = next; // bucket位直接指向下一个
else
prev.next = next; // 否则修改上一个entry的下一个指针为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;
}
}
}
}
// 每次获取buckets数组时，都先进行一次删除entry操作
private Entry<K,V>[] getTable() {
expungeStaleEntries();
return table;
}4.put函数
public V put(K key, V value) {
// null key值处理成空对象
Object k = maskNull(key);
int h = hash(k);
Entry<K,V>[] tab = getTable();
int i = indexFor(h, tab.length);
// 判断key是否存在，如果存在put新值，返回旧值
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;
}5.remove函数
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;
}6.内部类-Entry
从put()函数中发现key并没有被转换成弱引用，key只有在第一次被放入buckets数组时才需要转换成弱引用，也就是new Entry<>(k, value, queue, h, e)，WeakHashMap的Entry实现其实就是WeakReference的子类。
看一下Entry的源码：
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();
}
}关于Reference的解读，可以参考JDK源码Reference这片文章。
519
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
