final V putVal(K key, V value, boolean onlyIfAbsent) {
// 不允许 key或value 为null,HashMap允许 key 为null
if (key == null || value == null) throw new NullPointerException();
// 计算hash,将key的hashCode的高16位和低16位进行异或,增大随机性,HASH_BITS为0x7fffffff,二进制为11111111111111111111111111111111,进行&操作,如果两个都是1则为1,否则为0,这样为1和为0的概率都为百分之五十,这样做也是为了增大hash的随机性,减少hash碰撞的几率
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh; K fk; V fv;
// 判断tab是不是空或者tab的长度是否等于0,如果满足条件,则说明数组没有初始化,需要进行数组的初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 当前数组上的位置的元素为null,则创建一个Node使用CAS操作将元素放到桶中,并且终止循环。
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
break; // no lock when adding to empty bin
}
// 当前桶节点正在处于MOVED状态,说明正在扩容,那么就帮助进行扩容。
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 需要替换已有值,则替换,否则不替换
else if (onlyIfAbsent // check first node without acquiring lock
&& fh == hash
&& ((fk = f.key) == key || (fk != null && key.equals(fk)))
&& (fv = f.val) != null)
return fv;
else {
V oldVal = null;
synchronized (f) {
if (tabAt(tab, i) == f) {
// static final int MOVED = -1; // hash for forwarding nodes
// static final int TREEBIN = -2; // hash for roots of trees
// static final int RESERVED = -3; // hash for transient reservations
// fh >= 0 此节点为链表结构
if (fh >= 0) {
binCount = 1;
// 循环链表,在尾节点上添加元素,此时binCount在自增,binCount为后续判断是否将链表转为树结构的条件之一
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 新元素待放位置上已有元素
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
// 需要替换已有值,则替换,否则不替换
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
// 将新元素添加到尾节点上
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key, value);
break;
}
}
}
// 此节点为树结构
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
// 将元素添加到树节点上,若p != null,说明要放置的的节点上已有值,
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
// 需要替换已有值,则替换,否则不替换
if (!onlyIfAbsent)
p.val = value;
}
}
// TODO
else if (f instanceof ReservationNode)
throw new IllegalStateException("Recursive update");
}
}
if (binCount != 0) {
// 节点元素为链表且链表上元素总数>=8
if (binCount >= TREEIFY_THRESHOLD)
// 树化tab
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// 首先判断table为空时,会对数组进行初始化
while ((tab = table) == null || tab.length == 0) {
// sizeCtl默认值为0,如果sizeCtl小于0,根据sizeCtl的注释可以得知,说明table正在初始化,如果正在初始化,则当前线程让出CPU执行权,因为只能有一个线程去初始化table。
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// 如果sizeCtl大于0,则尝试使用CAS进行替换将SIZECTL,替换为-1,如果替换成功,就由当前线程去做table的初始化。
else if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
try {
// 再次判断table为空时,对数组进行初始化
if ((tab = table) == null || tab.length == 0) {
// 因为默认sc为0,默认容量为DEFAULT_CAPACITY 16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
// table不为空,table.length>0, hash下表桶上有元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 当前桶节点hash值和计算的hash相等,并且key值也相等,则返回对应的value。
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// 如果桶节点的hash值小于0,则说明是红黑树,使用TreeNode的find方法,对红黑树的节点进行遍历,直到找到key相等的元素返回对应value。
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
// 桶节点下面不是红黑树,说明是一个链表,对链表进行遍历,直到遍历到key相等的元素返回对应value。
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}