ConcurrentHashMap
HasMap是一种经常会用到的一种数据结构，但是它在多线程的环境下是不安全的，扩容时会出现循环依赖问题。
ConcurrentHashMap是JUC包下实现并发Map的工具类，大量使用CAS和synchronized在多线程环境下保证线程安全。
结构
都知道HashMap的数据结构为数组+链表，在出现hash碰撞时会在统一节点处生成一条链表。1.7和1.8中的区别是1.8会在超过8个时生成红黑树(时间复杂度为LogN),而单向链表的平均复杂度为n/2，其中有个问题是为什么是8(具体有待考证)？只要超过8个就一定变为红黑树吗?
重要概念:
-
table：默认为null，初始化发生在第一次插入操作，默认大小为16的数组，用来存储Node节点数据，扩容时大小总是2的幂次方。
-
nextTable：默认为null，扩容时新生成的数组，其大小为原数组的两倍。
-
sizeCtl:默认为0，用来控制table的初始化和扩容操作，具体应用后续会体现出来，-1代表table正在初始化，-N代表N-1个线程正在进行扩容操作，如果table未初始话，表示table初始化的大小，如果table初始化完成，表示table的容量默认是数组大小的0.75倍，计算公式(n-(n>>>2))
-
Node:保存key,value,hash值的数据结构
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
//val和next都会在扩容时发生变化，所以加上volatile来保持可见性和禁止重排序
volatile V val;
volatile Node<K,V> next;
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return val; }
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
public final String toString(){ return key + "=" + val; }
public final V setValue(V value) {
throw new UnsupportedOperationException();
}
public final boolean equals(Object o) {
Object k, v, u; Map.Entry<?,?> e;
return ((o instanceof Map.Entry) &&
(k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
(v = e.getValue()) != null &&
(k == key || k.equals(key)) &&
(v == (u = val) || v.equals(u)));
}
/**
* Virtualized support for map.get(); overridden in subclasses.
*/
Node<K,V> find(int h, Object k) {
Node<K,V> e = this;
if (k != null) {
do {
K ek;
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
} while ((e = e.next) != null);
}
return null;
}
}
- 特别注意ForwardingNode：一个特殊的Node节点，hash值为-1，其中存储nextTable的引用。hash=-1会在put中判断是否在扩容用到。
几个常量
/**
* node数组最大容量
*/
private static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认初始值，必须是2的幂数
*/
private static final int DEFAULT_CAPACITY = 16;
/**
* 数组可能最大值，需要与toArray（）相关方法关联
*/
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 并发级别，遗留下来的，为兼容以前的版本
*/
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 负载因子
*/
private static final float LOAD_FACTOR = 0.75f;
/**
* 链表转树的阀值，如果table[i]下面的链表长度大于8时就转化为数
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 树转链表的阀值，小于等于6是转为链表，仅在扩容tranfer时才可能树转链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。
* 这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 可用处理器数量
*/
static final int NCPU = Runtime.getRuntime().availableProcessors();
/**
* 扩容时用于存放数据的变量，扩容完成后会置为null。
*/
private transient volatile Node<K, V>[] nextTable;
/**
* 记录容器的容量大小，通过CAS更新
*/
private transient volatile long baseCount;
构造函数
一般使用默认构造函数，默认table大小为16，实际使用量为12.如果能估算出数据量的话尽量给定默认初始值，避免数据扩容带来资源开销。ConcurrentHashMap在实例化时只是给定了table的大小，table会在第一次put时初始化。在初始化table大小时会根据给定的值计算最近的2的幂次方赋值sizeCtl。
/**
* 默认的构造函数
*/
public ConcurrentHashMap() {
}
/**
* 指定容量的构造函数
*
* @param initialCapacity 初始化容量
* @throws IllegalArgumentException if the initial capacity of
* elements is negative
*/
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;//初始化sizeCtl
}
/**
* 返回大于等于count的最小的2的幂次方
*/
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
put源码
put过程中会涉及到ConcurrentHashMap的初始化table、并发原理、扩容机制。读懂put可以基本了解ConcurrentHashMap的原理。
* putVal方法可以分为以下几步：
* 1、检查key/value是否为空，如果为空，则抛异常，否则进行2
* 2、进入for死循环，进行3
* 3、检查table是否初始化了，如果没有，则调用initTable()进行初始化然后进行 2，否则进行4
* 4、根据key的hash值计算出其应该在table中储存的位置i，取出table[i]的节点用f表示。
* 根据f的不同有如下三种情况：
* 1）如果table[i]==null(即该位置的节点为空，没有发生碰撞)，则利用CAS操作直接存储在该位置，如果CAS操作成功则退出死循环。
* 2）如果table[i]!=null(即该位置已经有其它节点，发生碰撞)，碰撞处理也有两种情况
* 2.1）检查table[i]的节点的hash是否等于MOVED，如果等于，则检测到正在扩容，则帮助其扩容
* 2.2）说明table[i]的节点的hash值不等于MOVED，如果table[i]为链表节点，则将此节点插入链表中即可
* 如果table[i]为树节点，则将此节点插入树中即可。插入成功后，进行 5
* 5、如果table[i]的节点是链表节点，则检查table的第i个位置的链表是否需要转化为树，如果需要则调用treeifyBin函数进行转化
先来看一下整体源码
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();// key和value不允许null
int hash = spread(key.hashCode());//两次hash，减少hash冲突，可以均匀分布
int binCount = 0;//i处结点标志，0: 未加入新结点, 2: TreeBin或链表结点数, 其它：链表结点数。
// 主要用于每次加入结点后查看是否要由链表转为红黑树
for (Node<K, V>[] tab = table; ; ) {//CAS经典写法，不成功无限重试
Node<K, V> f;
int n, i, fh;//n为数组长度，i为计算后存储的位置，fh为添加节点的key.hash()
//检查是否初始化了，如果没有，则初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
/**
* i=(n-1)&hash 等价于i=hash%n(前提是n为2的幂次方).即取出table中位置的节点用f表示。 有如下两种情况：
* 1、如果table[i]==null(即该位置的节点为空，没有发生碰撞)，则利用CAS操作直接存储在该位置， 如果CAS操作成功则退出死循环。
* 2、如果table[i]!=null(即该位置已经有其它节点，发生碰撞)
*/
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//该节点没有值，直接赋值在该节点上
if (casTabAt(tab, i, null,
new Node<K, V>(hash, key, value, null)))
break; // no lock when adding to empty bin
} else if ((fh = f.hash) == MOVED)//检查table[i]的节点的hash是否等于MOVED，如果等于，则检测到正在扩容，则帮助其扩容
tab = helpTransfer(tab, f);
else {//table[i]的节点的hash值不等于MOVED且有冲突利用内置同步方式synchronized。
V oldVal = null;
// 针对首个节点进行加锁操作，而不是segment，进一步减少线程冲突
synchronized (f) {
//获得在i位置上的Node节点
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K, V> e = f; ; ++binCount) {
K ek;
// 如果在链表中找到值为key的节点e，直接设置e.val = value即可
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)//onlyIfAbsent为false表示直接将新值覆盖旧值
e.val = value;
break;
}
// 如果没有找到值为key的节点，直接新建Node并加入链表即可
Node<K, V> pred = e;
if ((e = e.next) == null) {//插入到链表末尾并跳出循环
pred.next = new Node<K, V>(hash, key,
value, null);
break;
}
}
} else if (f instanceof TreeBin) {// 如果首节点为TreeBin类型，说明为红黑树结构，执行putTreeVal操作
Node<K, V> p;
binCount = 2;
if ((p = ((TreeBin<K, V>) f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
// 如果节点数>＝8且所有键值对总是大于64，那么转换链表结构为红黑树结构
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);//MIN_TREEIFY_CAPACITY=64,若length<64,直接tryPresize,两倍table.length;不转红黑树
if (oldVal != null)
return oldVal;
break;
}
}
}
// 计数增加1，有可能触发transfer操作(扩容)
addCount(1L, binCount);
return null;
}
1.先进行两次hash始插入的位置更加散列，
2.接着判断table是否为空，空的话initTable()初始化。
initTable()
private final Node<K, V>[] initTable() {
Node<K, V>[] tab;
int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)//当sizeCtl小于0时，表示正在初始化，-N标识多个线程在初始化
Thread.yield(); // lost initialization race; just spin 线程让步
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
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);//n左移两位及变成1/4，设置扩容后，当前数组的最大临界值，结果为实际大小的3/4=0.75
}
} finally {
sizeCtl = sc;//赋值sizeCtl
}
break;
}
}
return tab;
}
当多个线程同时put时保证只有一个线程初始化table,其他线程Thread.yield()让步。
初始化线程通过U.compareAndSwapInt(this, SIZECTL, sc, -1)来原子操作设置SIZECTL=-1，每一次操作几乎都用到了CAS的方式去保证原子性。接着int n = (sc > 0) ? sc : DEFAULT_CAPACITY;再次判断sc，同时完成table容量值n的赋值，初始化赋值为16.
sc = n - (n >>> 2);设置sc的值为table容量的3/4，sizeCtl = sc;//赋值sizeCtl，正如前面说的sizeCtl 大于0时代表table的扩容阈值。
3.当table不为空时，tabAt(tab, i = (n - 1) & hash)获取hash值和(n-1)与运算获得位置i，tabAt获取该位置节点值为空直接赋值
4.当hash冲突时，判断hash是否为-1，此时就说明存在ForwardingNode节点，正在扩容中 tab = helpTransfer(tab, f);帮助一起扩容
5.正常情况下利用synchronized内置锁，而不是以前的segment的概念，将分段枷锁减小到一个node节点，粒度更小冲突也更小。使用synchronized而不用lock也是因为synchronized做过升降级优化，减少开销。
6.在节点f上进行同步，节点插入之前，再次利用tabAt(tab, i) == f判断，防止被其它线程修改。如果f.hash >= 0，说明f是链表结构的头结点，遍历链表，如果找到对应的node节点，则修改value，否则在链表尾部加入节点。
代码如下
synchronized (f) {
//获得在i位置上的Node节点
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K, V> e = f; ; ++binCount) {
K ek;
// 如果在链表中找到值为key的节点e，直接设置e.val = value即可
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)//onlyIfAbsent为false表示直接将新值覆盖旧值
e.val = value;
break;
}
// 如果没有找到值为key的节点，直接新建Node并加入链表即可
Node<K, V> pred = e;
if ((e = e.next) == null) {//插入到链表末尾并跳出循环
pred.next = new Node<K, V>(hash, key,
value, null);
break;
}
}
} else if (f instanceof TreeBin) {// 如果首节点为TreeBin类型，说明为红黑树结构，执行putTreeVal操作
Node<K, V> p;
binCount = 2;
if ((p = ((TreeBin<K, V>) f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
如果f是TreeBin类型节点，说明f是红黑树根节点，则在树结构上遍历元素，更新或增加节点。
binCount 用来存储链表中元素的个数，如果binCount >= TREEIFY_THRESHOLD判断转红黑树。
if (binCount != 0) {
// 如果节点数>＝8且所有键值对总是大于64，那么转换链表结构为红黑树结构
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);//MIN_TREEIFY_CAPACITY=64,若length<64,直接tryPresize,两倍table.length;不转红黑树
if (oldVal != null)
return oldVal;
break;
}
扩容
扩容出现在两个时间点：
1.判断binCount大于8之后，treeifyBin(tab, i)转红黑树时；
2.添加完节点之后 addCount(1L, binCount);增加计数时；前面有一个值private transient volatile long baseCount;保存节点数。
treeifyBin(tab, i);
private final void treeifyBin(Node<K, V>[] tab, int index) {
Node<K, V> b;
int n, sc;
if (tab != null) {
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1);//直接扩容两倍
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) {
if (tabAt(tab, index) == b) {
TreeNode<K, V> hd = null, tl = null;
for (Node<K, V> e = b; e != null; e = e.next) {
TreeNode<K, V> p =
new TreeNode<K, V>(e.hash, e.key, e.val,
null, null);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
setTabAt(tab, index, new TreeBin<K, V>(hd));
}
}
}
}
前面有一个静态量MIN_TREEIFY_CAPACITY=64，在进行红黑树转化时需要做一个判断table数组长度是否大于64这个阈值，如果小于冲突链表不转红黑树，直接tryPresize(n << 1);扩容数组table为原来的两倍。如果大于再同步将节点转为红黑树。
addCount(1L, binCount);
private final void addCount(long x, int check) {
CounterCell[] as;
long b, s;
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a;
long v;
int m;
boolean uncontended = true;
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();
}
if (check >= 0) {
Node<K, V>[] tab, nt;
int n, sc;
while (s >= (long) (sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
} else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}
final long sumCount() {
CounterCell[] as = counterCells;
CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
addCount
重点在if (check >= 0) 条件下
通过Unsafe.compareAndSwapInt修改sizeCtl值，保证只有一个线程能够初始化nextTable，扩容后的数组长度为原来的两倍，但是容量是原来的1.5。transfer方法扩容，主要就是新建一个数组将原数组元素进行复制到新数组，最后将table指向nextTab.其中优化一点就是新复制过去的节点顺序不变。还有一点就是transfer过程中当链表上节点个数少于6时才会由红黑树变为链表，当大于8是链表转为红黑树，这样做避免高并发下来回切换(有待具体考证，自己记录一下)。
get(Object)
/**
* 根据key在Map中找出其对应的value，如果不存在key，则返回null，
* 其中key不允许为null，否则抛异常
* 对于节点可能在链表或树上的情况，需要分别去查找
*
* @throws NullPointerException if the specified key is null
*/
public V get(Object key) {
Node<K, V>[] tab;
Node<K, V> e, p;
int n, eh;
K ek;
int h = spread(key.hashCode());//两次hash计算出hash值
//根据hash值确定节点位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 搜索到的节点key与传入的key相同且不为null,直接返回这个节点
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
} else if (eh < 0)//如果eh<0 说明这个节点在树上 直接寻找
return (p = e.find(h, key)) != null ? p.val : null;
//否则遍历链表 找到对应的值并返回
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
remove(Object)
final V replaceNode(Object key, V value, Object cv) {
int hash = spread(key.hashCode());
for (Node<K, V>[] tab = table; ; ) {
Node<K, V> f;
int n, i, fh;
if (tab == null || (n = tab.length) == 0 ||
(f = tabAt(tab, i = (n - 1) & hash)) == null)
break;
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
boolean validated = false;
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
validated = true;
for (Node<K, V> e = f, pred = null; ; ) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
V ev = e.val;
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) {
oldVal = ev;
if (value != null)
e.val = value;
else if (pred != null)
pred.next = e.next;
else
setTabAt(tab, i, e.next);
}
break;
}
pred = e;
if ((e = e.next) == null)
break;
}
} else if (f instanceof TreeBin) {
validated = true;
TreeBin<K, V> t = (TreeBin<K, V>) f;
TreeNode<K, V> r, p;
if ((r = t.root) != null &&
(p = r.findTreeNode(hash, key, null)) != null) {
V pv = p.val;
if (cv == null || cv == pv ||
(pv != null && cv.equals(pv))) {
oldVal = pv;
if (value != null)
p.val = value;
else if (t.removeTreeNode(p))
setTabAt(tab, i, untreeify(t.first));
}
}
}
}
}
if (validated) {
if (oldVal != null) {
if (value == null)
addCount(-1L, -1);
return oldVal;
}
break;
}
}
}
return null;
}
总结：
1.ConcurrentHashMap节点val和next都会在扩容时发生变化，所以加上volatile来保持可见性和禁止重排序。
2.ConcurrentHashMap的数据结构为数组+链表，链表在长度大于8且总table长度大于64时转化为红黑树。初始长度为16，负载因子为0.75.
3.在ConcurrentHashMap初始化时不会初始化table只是设置sizeCtl大小，在第一次put时initTable.
4.ConcurrentHashMap在添加和扩容时主要采用cas原子操作和synchronized内置锁来保证并发安全，分段粒度为节点冲突更小。
5.变为红黑树为什么是8，一方面是因为8是2的幂次方，在一个红黑树的平均复杂度为logN,链表的复杂度为N/2,log8=3,8/2=4，6/2=3(有待具体考证)
有两个问题补充一下：
1.HashMap允许Key和Value为null，而ConcurrentHashMap不允许。
首先value不能为空主要还是并发的原因，当我们在get(key)返回null时，单线程情况下我们可以containskey(object),去判断一下是本身key对应的value=null还是根本不存在key.然而在多线程中当我们在get(key)=null之后验证containskey(object)之前，另一个线程put(key,null),我们的判断containskey(object)会返回true.造我们开始的时候结果是不准确的。如果允许为空我们在操作的时候都要做两部操作get(key) containskey(key),会浪费资源。
至于key不能为空，应该是为了统一吧，毕竟null值不友好。我们谁也不太可能存map时使用null.
其中null是不能做hash的，在HashMap中包装了一层运算
static final int hash(Object key) {
int h;
//计算key的hashCode, h = Objects.hashCode(key)
//h >>> 16表示对h无符号右移16位，高位补0，然后h与h >>> 16按位异或
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
2.HashMap不允许通过Iterator遍历的同时通过HashMap修改，而ConcurrentHashMap允许该行为，并且该更新对后续的遍历可见.
HashMap中源码
//初始化迭代器
public final Iterator<K> iterator()
{ return new KeyIterator(); }
final class KeyIterator extends HashIterator
implements Iterator<K> {
public final K next() { return nextNode().key; }
}
abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() {
//将hashmap结构被改变的次数modcount赋值给expectedModCount，
expectedModCount = modCount;
Node<K,V>[] t = table;
current = next = null;
index = 0;
if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);
}
}
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
//首先判断是都有变化
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
modCount是记录hashmap结构更改次数，put \remove时都会modCount++
(1).创建迭代器Iterator iterator=ConcurrentHashMap.keySet().iterator();此时初始化HashIterator 赋值 expectedModCount = modCount;
(2).当迭代器向下迭代时nextNode()回去判断modCount是否有变化，有变化则抛出异常。
ConcurrentHashMap源码
public final K next() {
Node<K, V> p;
if ((p = next) == null)
throw new NoSuchElementException();
K k = p.key;
lastReturned = p;
advance();
return k;
}
final Node<K,V> advance() {
Node<K,V> e;
if ((e = next) != null)
e = e.next;
for (;;) {
Node<K,V>[] t; int i, n; // must use locals in checks
if (e != null)
return next = e;
if (baseIndex >= baseLimit || (t = tab) == null ||
(n = t.length) <= (i = index) || i < 0)
return next = null;
if ((e = tabAt(t, i)) != null && e.hash < 0) {
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
e = null;
pushState(t, i, n);
continue;
}
else if (e instanceof TreeBin)
e = ((TreeBin<K,V>)e).first;
else
e = null;
}
if (stack != null)
recoverState(n);
else if ((index = i + baseSize) >= n)
index = ++baseIndex; // visit upper slots if present
}
}
ConcurrentHashMap在向下迭代时会通过e = tabAt(t, i)去获取最新值，赋值给next对象。
[1]: https://www.jianshu.com/p/c0642afe03e0
[2]: https://www.jianshu.com/p/e694f1e868ec
962
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
