ConcurrentHashMap源码分析
1、底层原理
-
jdk 7 分段锁+数组+链表+红黑树
-
segment数组，每个segment都包含锁；继承可重入锁，需要手动上锁和解锁
-
若多个线程得到的segment索引冲突时，只能有一个线程先执行完毕，其他线程才有可能执行；若得到的索引不冲突则不会阻塞其他线程的进行。
-
segment数组的长度也决定着最多能支持几个线程并发执行。
-
-
每个segment下都含有table数组，来记录entry键值对，笔者觉得可以理解为每个segment下都是一个hashmap，数组+链表+红黑树的原理与hashmap相似，详情可看
hashmap源码分析博客
-
-
jdk 8
- 基于数组+链表+红黑树，取消了segment字段
- 在操作过程使用sychronized和CAS来实现线程安全。
- CAS原理：当线程要修改某个值时，线程先读取该值，经过一系列需要进行的操作后，再读取一遍，如果该值没有变，则赋予新值；如果值改变，则再进行一次（读取、系列操作、再读取），直至值前后没有变化。
//部分源码
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
//volatile 保证变量的可见性 -> 好处：在读操作时不需要加锁
//多线程环境下，线程1对结点的val/next的修改对其他线程是可见的
volatile V val;
volatile Node<K,V> next;
//不允许通过setValue方法来对val赋值
}
2、数组初始化
当添加第一个数据时，数组进行初始化
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)//表明已经有其他线程在初始化或扩容了
Thread.yield(); // 挂起当前线程
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//操作更新SIZECTL为-1，表明初始化状态
try {
if ((tab = table) == null || tab.length == 0) {
//默认为16或者用户传入的参数，同样必须是2的幂次方
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);//最多承载元素个数为数组长度的0.5倍
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
3、put 方法
concurrenthashmap 不支持key或者value为空，会抛出空指针异常
- 判断数组是否为空，空则进行初始化
- 计算得到索引下标，若当前下标为空，则使用CAS保证线程安全，直接插入结点；
- 若不为空，使用synchronized保证线程安全，进行添加操作
- 则判断是否为链表结构
- 是否有相同key值的结点，是则覆盖
- 否则遍历到链表结尾，尾插法
- 否则为红黑树结构，插入节点
- 判断是否需要树化；过程是否发生新值覆盖，是则返回旧值
- 最后通过addCount方法
- 判断是否进行数组元素个数的增加
- 整个数组元素个数是否超过最多承载数量sizeCtl，是则进行扩容
public V put(K key, V value) {
return putVal(key, value, false);//第三个参数只有当value为空时才会设置
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();//key value都不能为空
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)//数组为空
tab = initTable();//数组初始化
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//对应索引为空
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))//采用cas来保证线程安全
break;
}
else if ((fh = f.hash) == MOVED)//MOVED则说明当前正在对这个数组扩容
tab = helpTransfer(tab, f);//判断是否需要帮忙扩容
else {//结点不为空，也不在扩容
V oldVal = null;
synchronized (f) {//采用synchronized加锁，进行添加操作
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
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;//含有相同key的结点
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, null);
break;
}
}
}
else if (f instanceof TreeBin) {//树结构
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) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);//是否需要树化
if (oldVal != null)
return oldVal;//返回旧值
break;
}
}
}
addCount(1L, binCount);
return null;
}
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
//新的数组nextTab已经存在的前提下才能帮助扩容
//ForwardingNode结点表明正在扩容的结点
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
int rs = resizeStamp(tab.length);
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
4、扩容
4.1 扩容的时机
- 链表个数超8个，但数组长度小于64，扩容，分散链表的结点
- 结点个数超过最多能承载的结点个数时，扩容
- 当某线程要对数组中的元素进行操作时，如果检测到结点的hash值为MOVED时，调用helpTransfer方法，在该方法中调用transfer方法来帮助完成数组的扩容。
以下部分参考ConcurrentHashMap原理分析(二)-扩容
4.2 扩容的流程
- 根据CPU核数和数组length计算每个核一轮处理桶的个数，最小是16
- 修改
transferIndex标志位，每个线程领取完任务就减去多少，比如初始大小是transferIndex= table.length = 64，每个线程领取的桶个数是16，第一个线程领取完任务后transferIndex= 48，也就是说第二个线程这时进来是从第48个桶开始处理，再减去16，依次类推，这就是多线程协作处理的原理 - 领取完任务之后就开始处理，如果桶为空就设置为
ForwardingNode，如果不为空就加锁拷贝，拷贝完成之后也设置为ForwardingNode节点 - 如果某个线程分配的桶处理完了之后，再去申请，发现
transferIndex= 0，这个时候就说明所有的桶都领取完了，但是别的线程领取任务之后有没有处理完并不知道，该线程会将sizeCtl的值减1，然后判断是不是所有线程都退出了，如果还有线程在处理，就退出 - 直到最后一个线程处理完，发现
sizeCtl = rs<< RESIZE_STAMP_SHIFT，将新数组赋值原数组，并且会重新设置sizeCtl为新数组的扩容点
以上过程总的来说分成两个部分：
- 分配任务部分：这部分其实很简单，就是把一个大的数组给切分，切分多个小份，然后每个线程处理其中每一小份，当然可能就只有1个或者几个线程在扩容，那就一轮一轮的处理，一轮处理一份
- 处理任务部分：复制部分主要有两点，第一点就是加锁，第二点就是处理完之后置为
ForwardingNode
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
/* 判断CPU是不是多核
是则将 n / 8 除以 CPU核心数,如果得到的结果小于 16，那么就赋值为16
否则单核处理完所有任务 一个数组对应的索引为一个任务
这里的目的是让每个 CPU 处理的桶一样多，避免出现转移任务不均匀的现象，如果桶较少的话，默认一个
*/
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE;
if (nextTab == null) { // 新数组还未初始化
try {
@SuppressWarnings("unchecked")
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;//transferIndex 表示转移时的下标，初始为扩容前的 length，可以理解为还有多个任务要完成
}
int nextn = nextTab.length;
// 创建一个 fwd 节点，用于占位。当别的线程发现这个槽位中是 fwd 类型的节点，则跳过这个节点。
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
/* 如果等于 true，说明需要再次推进一个下标（i--），
反之，如果是 false，那么就不能推进下标，需要将当前的下标处理完毕才能继续推进*/
boolean advance = true;
boolean finishing = false; //表明数组还未完成复制结点过程
// i 表示下标，bound 表示当前线程可以处理的当前桶区间最小下标，死循环的作用是保证拷贝全部完成
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
/* 如果当前线程可以向后推进；这个循环就是控制 i 递减。
同时，每个线程都会进入这里取得自己需要转移的桶的区间即[nextBound,nextIndex]
这个循环只是用来控制每个线程每轮最多copy的桶的个数，
如果只有一个线程在扩容，也是可以完成的，只是分成多轮
*/
while (advance) {
int nextIndex, nextBound;
/* 对 i 减一，判断是否大于等于 bound
（如果大于 bound 不成立，说明该线程上次领取的任务已经完成了。那么，需要在下面继续领取任务）
如果对 i 减一大于等于 bound，说明还需要继续做任务，
或者整个过程finishing已经完成了，修改推进状态为 false，不能推进了。
任务成功后修改推进状态为 true。
通常，第一次进入循环，i-- 这个判断会无法通过，进行 nextIndex 赋值操作（获取最新的转移下标）
其余情况都是：如果可以推进，将 i 减一，然后修改成不可推进。
如果 i 对应的桶处理成功了，改成可以推进。
*/
if (--i >= bound || finishing)
advance = false;
// 这里的目的是：1. 当一个线程进入时，会选取最新的转移下标。
//2. 当一个线程处理完自己的区间时，如果还有剩余区间的没有别的线程处理，再次获取区间。
else if ((nextIndex = transferIndex) <= 0) {
/* 如果小于等于0，说明没有区间了 ，i 改成 -1，推进状态变成 false，
扩容结束了，当前线程可以退出了
这个 -1 会在下面的 if 块里判断，从而进入完成状态判断*/
i = -1;
advance = false;
}
// CAS 修改 transferIndex，即 length - 区间值，留下剩余的区间值供后面的线程使用
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;// 这个值就是当前线程可以处理的最小当前区间最小下标
i = nextIndex - 1;// 初次对i 赋值，这个就是当前线程可以处理的当前区间的最大下标
advance = false;
}
}
// 如果 i 小于0 （不在 tab 下标内，按照上面的判断，领取最后一段区间的线程扩容结束）
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {//是否已完成复制
nextTable = null;
table = nextTab;//赋值新数组
sizeCtl = (n << 1) - (n >>> 1);//为原数组长度的1.5倍
return;
}
//CAS 更改扩容阈值，在这里面sizectl值减一，说明新加入一个线程参与到扩容操作
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;// 不相等，说明没结束，当前线程结束方法。
finishing = advance = true;// 如果相等，扩容结束了，更新 finising 变量
i = n; // 再次循环检查
}
}
// 遍历的节点为null，则放入到ForwardingNode 指针节点,占位，别的线程可直接跳过这个结点
else if ((f = tabAt(tab, i)) == null)
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) {//链表结构
int runBit = fh & n;
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;//该结点完成复制
}
else if (f instanceof TreeBin) {//树结构
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;//该结点完成复制
}
}
}
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
