HashMap分析
HashMap是一个存放多组key-value值的map。是由一组Node<K,V>[]数组组成的。它的key不能重复,可以为null。
它默认的负载因子loadFactor是0.75, 默认容量是16,实际容量是16 * 0.75为12,每次扩容都是16的倍数。通过负载因子可以减少哈希碰撞,避免多个key挤在一个位置上,其他数组的位置上没值。
hash():hash == key.hashCode ^ hash>>>16
在put时:
- 计算key的hashCode,然后通过数组的length & hash值的方式得到数组的下标
- 如果数组下标的位置没有存放值,那么就直接放进去。
- 如果有元素,就判断这个元素的hash值是否等于第一步计算的hash,如果是,就将value覆盖
- 如果已存在的元素不是要添加的元素,那么就判断这个元素是否是红黑树节点,是的话以红黑树的方式插入
- 如果不是,表明是链表,就以插入链表的方式插入到尾部。然后检测这条链表的长度是否大于8,大于的话就转换成红黑树。
- 在插入完成后,将传入的value赋给新的节点
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// map的Node<K,V>[]数组未初始化,进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 通过table.length & key.hash得到这个对象应放的下标i
// 如果这个下标没有值,直接构造个新节点,并且放到数组里
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// 下标对应的有值
Node<K,V> e; K k;
// 判断已存在值的hash是否等于传入的对象的hash,是的话,表示这两个对象的key相同
// 直接覆盖value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
// 如果已存在的是树节点,那么以红黑树的方式插入一个节点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 如果是链表,构造节点循环插入到尾部。如果链表长度大于8,那么转换为二叉树
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 传进来的值已经存在在链表上
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 赋值操作
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 检查当前节点是否是尾节点,避免多线程下的并发
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 容量超出的话,开始扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
get()方法:
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 判断map是否为null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // 查看数组对应下标的first元素是否是要找的
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
// 取到first的next,如果是树节点,就返回树节点
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
// 链表的查找
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
Fail-Fast机制:
通过modCount域(修改次数),对HashMap的修改都会使它自增。在迭代HashMap时,迭代之前获取一次这个值,迭代之后获取一次这个值。如果2次的值不相等,表明别的线程在迭代的时候修改了HashMap,这时候就抛出ConcurrentModificationException异常。
HashMap在扩容时,判断每个数组的数的长度大于6,就转换成链表
HashMap为什么是线程不安全的
因为它的put和resize都是非同步的,在多线程的情况下,put方法可能会导致统计不正确(++modCount)和数据丢失。而resize扩容方法,2个线程同时进,最终只会有一个线程成功,其他线程都失败,数据就丢失了。