目录
HashMap
插入新数据：
- 检查table是否为null或数据为空（table的初始化发生在第一次put数据时）；
- 计算新数据在table的索引i = (length-1) & hash(key)；
- 判断table索引处是否存在key数据，通过 (k = p.key) == key || (key != null && key.equals(k))；
- 如果该索引处没有数据，则直接插入新数据；
- 如果该索引处数据为红黑树节点，在树的正确位置插入数据；
- 如果该索引是链表节点，遍历链表定位尾节点；
- 如果在遍历链表时发现已存在key数据，则记录该条旧数据并退出遍历；
- key重复时，如果不保留旧数据或者旧数据value为null，则覆盖旧数据，此时不会造成数据量的增加，不进行下一步扩容检查；
- 如果key不重复，则在链表尾节点后插入新数据，插入数据后，当链表长度达到TREEIFY_THRESHOLD(默认8)- 1，则链表转换成红黑树以提升查找性能；
- 插入新数据后进行扩容检查resize();
- 先对table容量和负载阈值进行边界检查和2倍扩容（newCapacity = oldCapacity*2 ）；
- 再使用新容量分配newTab，将oldTab中数据存储到newTab。
// 外接方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}计算key的hash值，如果key为null，则hash值为0（也就是说允许null键）
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}插入新数据
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
// 如果table为null或无数据
// 对table进行resize()，初始化table容量为默认值16， 阈值为默认负载因子75%*table容量=12
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// 计算新数据在table的索引i = (length-1) & hash(key)
// 如果该索引处没有数据，则直接插入新数据
tab[i] = newNode(hash, key, value, null);
else {
// 如果该索引处已经存在数据，则进行散列（）
Node<K,V> e; K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
// 如果key重复，则覆盖
e = p;
else if (p instanceof TreeNode)
// 如果该索引处元素是红黑树节点（红黑树散列）
// 则在该树中正确插入新数据
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 链表散列
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 在链表尾节点后插入新数据
p.next = newNode(hash, key, value, null);
// 当链表长度达到上限（默认8），转换为红黑树散列
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
// 成功插入数据，则退出散列
break;
}
// 散列过程中如果遇到key重复，则覆盖
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
// 从上面来看，在key重复时，记录旧数据e
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//onlyIfAbsent决定key重复时,是否保留旧数据, 如果为true则保留, false则覆盖原有值, 默认false。 覆盖旧值或者旧值为null时，更新为新数据
e.value = value;
afterNodeAccess(e); // 空方法（只被linkhashmap重写使用）
// 覆盖数据不会导致数据量的变化，因此不进行后面的扩容检查，直接返回旧数据退出方法
return oldValue;
}
}
++modCount;
if (++size > threshold)
// 如果table中数据达到上限，则进行扩容
resize();
afterNodeInsertion(evict);
return null;
}扩容过程
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
// 如果容量已经达到最大上限（static final int MAXIMUM_CAPACITY = 1 << 30;）
// 不再进行扩容，而是放宽负载阈值
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 如果2倍扩容后容量未达到最大上限，并且原始容量达到初始默认容量，则进行2倍扩容（这里先将负载阈值乘了2）
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
// 如果table为null或数据为空，但是负载阈值不为0，设置新容量为负载阈值（？？？）
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 容量为0，阈值为0（未使用阶段），设置默认值（16， 12）
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 如果扩容后负载阈值为0，重新计算负载阈值=容量*负载因子
float ft = (float)newCap * loadFactor;
// 检验边界情况
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 扩容后，将旧数据移动到新table中
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"}) //压制警告
// 分配新容量大小的数组newTab
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
// 如果该节点没有散列， 计算该节点在newTab中的索引（(length - 1) & hash ）， 将该节点存储到newTable
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 如果该节点是红黑树节点，重构树或者变成链表，存储到newTab
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 如果该节点是链表节点，遍历存储到newTab
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
// 返回newTab
return newTab;
}HashTable
- 构造HashTable时就会初始化table，默认初始容量11，负载因子0.75；
- 计算新数据在table的索引index = (hash & 0x7FFFFFFF) % length；
- 获取索引处的Entry对象，遍历next；
- 如果发现key重复，新数据直接覆盖旧值，并返回旧
- 如果key没有重复，则先检查当前数据量是否达到负载阈值，
- 如果已经达到负载阈值，则进行扩容,先对table容量扩容（newCapacity = oldCapacity*2+1 ）和边界检测，计算负载阈值，将旧table中数据存储到新table中；
- 如果进行扩容，重新计算索引（因为数据发生移动）；
- 为新数据生成新的Entry对象，next属性记录索引处原Entry对象，并将新Entry对象存储到索引处
public synchronized V put(K key, V value); 使用同步锁保证线程安全
public synchronized V put(K key, V value) {
// hashtable不允许null键和null值
if (value == null) {
throw new NullPointerException();
}
Entry<?,?> tab[] = table;
// 计算新数据将要存储到table的索引值index = (hash & 0x7FFFFFFF) % length
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked") //压制警告
// 拿到索引处的entry
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
// 遍历过程中如果发现key重复，则覆盖旧值，并直接返回旧值
V old = entry.value;
entry.value = value;
return old;
}
}
// 如果key没有重复，则在正确位置插入新数据
addEntry(hash, key, value, index);
return null;
}插入新数据
private void addEntry(int hash, K key, V value, int index) {
Entry<?,?> tab[] = table;
if (count >= threshold) {
// 插入新数据前，先检查数据量是否达到上限，是的话先进行扩容
rehash();
// 然后重新计算新数据在新table中的索引
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
@SuppressWarnings("unchecked") //压制警告
// 拿到索引处的原Entry对象
Entry<K,V> e = (Entry<K,V>) tab[index];
// 为新数据创建新Entry对象，新Entry对象中的entry属性保存索引处的原Entry对象
// 将新Entry对象存储在该索引处（相当于在头节点插入数据）
tab[index] = new Entry<>(hash, key, value, e);
count++;
modCount++;
}扩容过程
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// 扩容：newCapacity = oldCapacity*2 +1
int newCapacity = (oldCapacity << 1) + 1;
// 边界检测
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
// 分配新的内存空间
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
// 计算负载阈值
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
// 将旧table中的数据保存到新table中
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}为新数据生成Entry对象
private static class Entry<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
// 记录下一个Entry对象，拉链散列
Entry<K,V> next;
protected Entry(int hash, K key, V value, Entry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}ConcurrentHashMap
- 和HashMap类似，创建ConcurrentHashMap未对table初始化，在第一次put数据时先检查table初始化；
- 如果已经初始化了，计算新数据在table中的索引i = (length - 1) & hash)；
- 如果索引处没有数据，CAS插入新数据；
- 如果索引处已存在数据，拿到索引处节点，判断是否处于迁移状态（表示table正在扩容）；
- 如果正在迁移，当前线程加入到协助扩容的工作；
- 以索引处节点为锁对象加同步锁，遍历该桶中节点；
- 如果遇到key重复，默认新数据覆盖旧数据，覆盖数据不需要扩容检查，直接返回旧数据退出put，如果没有重复；
- 如果是链表散列，在链表尾部插入新数据，如果链表长度达到TREEIFY_THRESHOLD（默认8），转换为红黑树散列；
- 如果是红黑树散列，通过工具类TreeBin插入新数据；
- 插入数据后，进行扩容检查
// 外接方法
public V put(K key, V value) {
//
return putVal(key, value, false);
}插入新数据
final V putVal(K key, V value, boolean onlyIfAbsent) {
// ConcurrentHashMap不允许null键和null值
if (key == null || value == null)
throw new NullPointerException();
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;
if (tab == null || (n = tab.length) == 0)
// 和hashmap一样，创建时没有对table创建和初始化，在第一次put数据时创建和初始化table
tab = initTable();
// 计算新数据的索引i = (length - 1) & hash
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果索引处没有数据，为新数据生成Node节点，以CAS方式在索引处插入
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
break; // no lock when adding to empty bin
}
// static final int MOVED = -1; // hash for forwarding nodes
// 检测到f结点是 ForwardingNode 类型，表明当前table正在扩容，则让当前线程加入到扩容工作中协助扩容
else if ((fh = f.hash) == MOVED)
// 扩容
tab = helpTransfer(tab, f);
else if (onlyIfAbsent
&& fh == hash
&& ((fk = f.key) == key || (fk != null && key.equals(fk)))
&& (fv = f.val) != null)
// key重复但是onlyIfAbsent为true(保留旧值)，则不会进行数据的修改，直接返回旧值退出put
return fv;
else {
// 索引处存在数据f节点，并且与新数据key不重复，则需要遍历以f节点为头节点的链表或以f节点为根节点的红黑树，在正确的位置插入新数据（或者碰到key重复更新或保留数据）
V oldVal = null;
synchronized (f) {
// 将f节点作为同步锁
if (tabAt(tab, i) == f) {
// 检验tab索引处是否为f节点
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
// 遍历以f节点为头节点的链表
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
// 如果key重复，且onlyIfAbsent为false(更新旧值)，则直接更新该节点的value值为新数据（由synchronized保证线程安全）
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
// 定位到尾节点，为新数据生成Node节点，直接在尾节点后插入（由synchronized保证线程安全）
pred.next = new Node<K,V>(hash, key, value);
break;
}
}
}
else if (f instanceof TreeBin) {
// 如果索引处f节点为红黑树节点
Node<K,V> p;
binCount = 2;
// putTreeVal在红黑树中正确位置插入新数据，如果遇到key重复，返回重复的节点
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
// 更新旧值
p.val = value;
}
}
else if (f instanceof ReservationNode)
// 保留节点，不存储数据
throw new IllegalStateException("Recursive update");
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
// 如果链表长度达到TREEIFY_THRESHOLD（默认8），转换为红黑树
treeifyBin(tab, i);
if (oldVal != null)
// 如果oldVal 不为null，则说明key重复，返回旧值
return oldVal;
break;
}
}
}
// 插入数据后，扩容检查（transfer）
addCount(1L, binCount);
return null;
}初始化table
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
// 如果sizeCtl为-1（<0）,说明已经有线程在初始化table， 当前线程让出CPU
Thread.yield();
// CAS修改sizeCtl为-1成功，开始初始化table
else if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 分配内存初始化table
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}当前线程加入到协助扩容的工作
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// table非为null并且f节点是转移类型，
// 获取扩容校验标识
int rs = resizeStamp(tab.length);
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
// 如果 nextTab 和 tab 也没有被并发修改，sizeCtl < 0 （正在扩容）
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
// 如果 sizeCtl 无符号右移16 不等于 rs
// 或者 sizeCtl == rs + 1（表示扩容结束）
// 或者 sizeCtl == rs + MAX_RESIZERS（如果达到最大帮助线程的数量）
// 或者转移下标正在调整（扩容结束）
// 结束循环
break;
if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1)) {
// CAS将sc+1，线程加入扩容任务
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}transfer扩容
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
//stride 即步进，在单核下为 table 的长度 n，在多核模式下为 (n >>> 3) / NCPU，最小值为 16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE;
// 如果 nextTable 未初始化，则先进行初始化，容量是之前的两倍
if (nextTab == null) {
try {
@SuppressWarnings("unchecked")
// 2倍扩容，初始化新table
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) {
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;
}
// 执行迁移工作
int nextn = nextTab.length;
// 定义 ForwardingNode 表示一个正在被迁移的结点，对应的 hash 值是 MOVED
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false;
// i 是索引，bound 是边界值，从后往前迁移
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
// 从后往前遍历，transferIndex<=0，表示迁移完成
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 更新 transferIndex，为当前线程分配任务，处理的桶结点区间为（nextBound,nextIndex）
else if (U.compareAndSetInt(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// 数据迁移到新table中后
if (i < 0 || i >= n || i + n >= nextn) {
//finnish为true，说明整张表的迁移操作已经全部完成
int sc;
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
if (U.compareAndSetInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
//CAS将sizeCtl减一，表示当前线程已经完成了任务，退出扩容操作
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
//整个table的扩容工作未完成，只退出当前线程的的扩容工作
return;
finishing = advance = true;
i = n;
}
}
else if ((f = tabAt(tab, i)) == null)
// 如果索引处f节点为null，CAS更新table索引处为新数据
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED)
// 正在执行迁移工作
advance = true;
else {
// 扩容完成，开始进行数据迁移工作
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) {
// 链表迁移
// ...
}
else if (f instanceof TreeBin) {
// 红黑树迁移
// ...
}
}
}
}
}
}
1603
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
