IdentityHashMap和WeakHashMap源码阅读
IdentityHashMap
当比较key和value的时候，IdentityHashMap利用引用相等(==)来代替普通Map利用值相等(equals)。即IdentityHashMap中两个键值k1和k2当k1==k2则认为相等，普通map对象只有(k1==null ? k2==null : k1.equals(k2))才认为相等。 IdentityHashMap并非是通用目的的map类，它违背了一般Map的规则，它使用 “==” 来比较引用而不是调用Object.equals来判断相等。这个类用于一些比较罕见的场景要求引用相等的语义。
- 这个特性使得此集合在遍历图表的算法中非常实用，可以方便地在IdentityHashMap中存储处理过的节点以及相关的数据。
- 维持代理对象。例如一个调试器可能需要为每一个对象维持一个代理对象，当进行程序调试的时候。
IdentityHashMap和普通map类似支持为null的键或值，在散列均匀情况下，对于基本操作(put或get)提供常数时间。其实现是非线性安全，可以利用集合帮助类包裹返回同步容器Collections.synchronizedMap(new IdentityHashMap(...));。视图容器返回的迭代器支持fail-fast，迭代过程若容器发生结构修改，将抛出ConcurrentModificationException。
在实现层面，当发生散列冲突时，不同于HashMap采用链表方式处理冲突，IdentityHashMap采用线性探测方式，且所有键和值对都存在一个数组中。(对于大的散列表这种方式数据局部性比存放到不同数组中更好)。在很多JRE实现中，IdentityHashMap采用线性探测方式比HashMap链式处理策略性能更高。
类成员，可以看到内部数组直接是Object[]，用于存放key和value。同样size要保证为2的幂次。
private transient Object[] table;
private int size;
private transient int threshold; //capacity * load factorput和get方法，可以看到key存放在i位置(散列后插入位置)，value存放在i+1的位置。
public V put(K key, V value) {
Object k = maskNull(key);
Object[] tab = table;
int len = tab.length;
int i = hash(k, len);
Object item;
while ( (item = tab[i]) != null) {
if (item == k) { //存在key相等==,则替换value
V oldValue = (V) tab[i + 1];
tab[i + 1] = value;
return oldValue;
}
i = nextKeyIndex(i, len);
}
modCount++;
tab[i] = k;
tab[i + 1] = value;
if (++size >= threshold)
resize(len); // len == 2 * current capacity.
return null;
}
private static int hash(Object x, int length) {
int h = System.identityHashCode(x);
// Multiply by -127, and left-shift to use least bit as part of hash
return ((h << 1) - (h << 8)) & (length - 1);
}
//Circularly traverses table of size len.
private static int nextKeyIndex(int i, int len) {
return (i + 2 < len ? i + 2 : 0); //这里i+2由于同时存了key和value
}
public V get(Object key) {
Object k = maskNull(key);
Object[] tab = table;
int len = tab.length;
int i = hash(k, len);
while (true) {
Object item = tab[i];
if (item == k)
return (V) tab[i + 1];
if (item == null)
return null;
i = nextKeyIndex(i, len);
}
}remove方法，不能只是简单将hash位置对应的key和vlaue设置为null，由于采用线性探测解决冲突，需要对所有映射到该位置的元素进行位置调整。
public V remove(Object key) {
Object k = maskNull(key);
Object[] tab = table;
int len = tab.length;
int i = hash(k, len);
while (true) {
Object item = tab[i];
if (item == k) {
modCount++;
size--;
V oldValue = (V) tab[i + 1];
tab[i + 1] = null;
tab[i] = null;
closeDeletion(i);
return oldValue;
}
if (item == null)
return null;
i = nextKeyIndex(i, len);
}
}
private void closeDeletion(int d) {
// Adapted from Knuth Section 6.4 Algorithm R
Object[] tab = table;
int len = tab.length;
// Look for items to swap into newly vacated slot
// starting at index immediately following deletion,
// and continuing until a null slot is seen, indicating
// the end of a run of possibly-colliding keys.
Object item;
for (int i = nextKeyIndex(d, len); (item = tab[i]) != null;
i = nextKeyIndex(i, len) ) {
// The following test triggers if the item at slot i (which
// hashes to be at slot r) should take the spot vacated by d.
// If so, we swap it in, and then continue with d now at the
// newly vacated i. This process will terminate when we hit
// the null slot at the end of this run.
// The test is messy because we are using a circular table.
int r = hash(item, len);
if ((i < r && (r <= d || d <= i)) || (r <= d && d <= i)) {
tab[d] = item;
tab[d + 1] = tab[i + 1];
tab[i] = null;
tab[i + 1] = null;
d = i;
}
}
}WeakHashMap
WeakHashMap将键存储在WeakReference中，就是说，如果没有强引用指向键对象的话，这些键就可以被垃圾回收线程回收。值被保存在强引用中。因此，你要确保没有引用从值指向键或者将值也保存在弱引用中m.put(key, new WeakReference(value))。 WeakHashMap 类的行为部分取决于垃圾回收器的动作，所以，几个常见的（虽然不是必需的）Map 常量不支持此类。因为垃圾回收器在任何时候都可能丢弃键，WeakHashMap 就像是一个被悄悄移除条目的未知线程。
即使对 WeakHashMap 实例进行同步，并且没有调用任何赋值方法，在一段时间后size方法也可能返回较小的值，对于isEmpty方法，返回 false，然后返回true，对于给定的键，containsKey方法返回true然后返回false，对于给定的键，get 方法返回一个值，但接着返回null，对于以前出现在映射中的键，put方法返回 null，而remove 方法返回false，对于键set、值collection 和条目set进行的检查，生成的元素数量越来越少。
集合视图的迭代器支持fast-fail，迭代器创建以后，若非调用迭代器自身修改方法对容器进行结构修改，将会抛出ConcurrentModificationException。
类的定义
public class WeakHashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V> 类成员，和HashMap类似，都是采用数组加链表方式组织散列表，不过可以看到table对应数组的类型WeakHashMap$Entry，继承了WeakReference，没有看到key的定义，key值实际以弱引用方式存到父类中。
private Entry[] table;
private int size;
private int threshold; //(capacity * load factor).
private final float loadFactor;
//Reference queue for cleared WeakEntries
private final ReferenceQueue<K> queue = new ReferenceQueue<K>();
private static class Entry<K,V> extends WeakReference<K> implements Map.Entry<K,V> {
private V value;
private final int hash;
private Entry<K,V> next;
Entry(K key, V value, ReferenceQueue<K> queue, int hash, Entry<K,V> next) {
super(key, queue);
this.value = value;
this.hash = hash;
this.next = next;
}
public K getKey() {
return WeakHashMap.<K>unmaskNull(get());
}
} 成员方法，size方法返回只是当时散列表的大小的快照，这个大小在下次调用的时候值可能改变。其他基本操作方法put、get和remove等都和HashMap类似，主要不同在于key值获取通过Entry类中getKey()方法。
//返回size大小只是一个快照，引用可能被GC回收
public int size() {
if (size == 0)
return 0;
expungeStaleEntries(); //删除过时的entry
return size;
}
private void expungeStaleEntries() {
Entry<K,V> e;
while ( (e = (Entry<K,V>) queue.poll()) != null) {//删除queue准备回收的entry对象
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;
} //end while
}//end while
}Java对象中的引用
- 强引用。平时我们编程的时候例如：Object object=new Object（）；那object就是一个强引用了。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空 间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。
- 软引用(SoftReference)。如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。 软引用可以和一个引用队列(
ReferenceQueue)联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。 - 弱引用(WeakReference)。如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列(
ReferenceQueue)联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。 -
虚引用(PhantomReference)。”虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在 任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
在java.lang.ref包中提供了三个类：
SoftReference类、WeakReference类和PhantomReference类，它们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列，它可以和这三种引用类联合使用，以便跟踪Java虚拟机回收所引用的对象的活动。