java8 ConcurrentHashMap源码学习
ConcurrentHashMap
ConcurrentHashMap是一个HashMap的升级版，是线程安全的，想要了解ConcurrentHashMap就必须得要去了解他的put、get、扩容方法
这里必须说一下的是, 1.8的ConcurrentHashMap不是使用segment进行并发操作了, 现在太多误导人的博客了… 虽然源码中有segment但是整个put, get, 扩容的环节都与segment无关, 并没有使用segment进行并发控制
之前面试官问过我, 在concurrentHashMap中有哪些地方用到了cas, 这里列举一下
- casTabAt, 替换table中指定下标的桶
- transferIndex, 在扩容的时候transferIndex作为扩容的最终下标, 每个线程扩容stride个长度(扩容是从后往前的, 即从length到0), cas操作transferIndex可以保证线程安全, 每个线程成功修改transferIndex数值之后才会开始做扩容操作, 保证了每段有且仅有一个线程扩容
- sizeCtl, 这个参数在初始化的时候是-1, 在扩容的时候是根据表长度获得的一个大负数, 每有一个线程参与扩容该负数就+1, 完成扩容则-1, 线程扩容前访问该数判断扩容是否完成, 因此这个数需要用cas操作确保线程安全
- baseCount, 获取map的size的时候是通过baseCount与countCell统计获得的, 插入元素的时候如果baseCount的cas操作失败了则进入计数器做计数操作
put
public V put(K key, V value) {
return putVal(key, value, false);
}
可以看见这里调用了putVal
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
// 这里binCount是用于标记当前链表的长度
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// tab如果是空或者长度为0就进行初始化
// 在initTable中用cas替换sizeCtl为-1保证了table在多线程下只会被一个线程初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// tabAt方法中使用了本地方法getObjectVolatile,直接从内存中获取数组指定位置的值
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 该位置值为空则new一个结点使用cas替换, 这里cas保证了多线程下的原子性
// 若多个线程进入这一语句块, cas先比较table[i]的值是否为null, 若是则替换
// 所以只有一个线程的cas操作可以成功, 其他都失败
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// MOVED代表着当前位置有线程在进行扩容迁移, 该线程会加入迁移过程
// helpTransfer与transer操作几乎一样不多赘述
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// table已经被初始化过了, 当前节点不为空, 并且扩容没有在进行
else {
V oldVal = null;
// 将f上锁
synchronized (f) {
// 再次进行判断保证i结点还是之前的i结点
if (tabAt(tab, i) == f) {
// fh>=0说明这个f是链表, 若f是treebin, 在treebin中是没有hash这个变量的
if (fh >= 0) {
binCount = 1;
// 遍历f, 看看key是否已经存在
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;
// key不存在, 新增一个结点
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
// 当前结点是红黑树, 直接调用putTreeVal
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;
}
}
}
}
// binCount不为0说明新增了结点
if (binCount != 0) {
// binCount大于等于8, 调用treeifyBin
// 在treeifyBin中如果table容量小于64, 则会进行扩容而不是转换为红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 调用addCount, 将baseCount+1或者放入counterCells中
addCount(1L, binCount);
return null;
}
addCount
这个函数的功能就是将baseCount+x或者将x放入counterCells
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
// 首先判断计数器是否为空, 或者让s=b+x与baseCount进行cas交换, 若失败则进入语句块
// 这里失败了就会放弃累加baseCount转而将x存入计数盒子
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
// 这里有三个判断
// 1.计数器如果为空则直接调用fullAddCount进行计数器初始化, 上一个if中cas失败的场景
// 2.取一个随机数同数组-1进行与运算, 就是取余获取下标, 为空则调用fullAddCount
// 3.到了这一步即代表当前下标计数器不为空, 所以取当前值与x相加, cas交换
// 如果第三步也失败了, 那就调用fullAddCount并且uncontended是false
// fullAddCount就是一个计数的函数, 后面会讲到
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;
}
// 传入的binCount <= 1 就直接return不进行扩容检测
if (check <= 1)
return;
// s是当前table中数据的总数, 这里包括了baseCount和counterCells中的数
// 由于这个sumCount()的实现非常简单, 这里就不赘述了
s = sumCount();
}
// 传入的binCount >= 0就进行扩容检测, 这里可以发现put过来的只要到了这一步一定会检测
// 而addCount还有被其他方法调用, 所以这里需要做一个check判断
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// 这里的s就是上面的sumCount计算出来的数据
// s要大于需要扩容的长度, 基本上是table.length * 0.75
// 若容量已经比2^31还要大就无法扩容
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// RESIZE_STAMP_BITS默认为16
// 这里的rs用于标记, 是根据n和RESIZE_STAMP_BITS生成的一个高十六位负数
int rs = resizeStamp(n);
// sc正常来说是大于0的, 小于0的情况就是有线程在进行扩容, 那么这个线程就加入帮助
if (sc < 0) {
// 这里判断扩容是否已经完成
// 1.sc右移16位查看标志位是否相等
// 2.sc如果等于rs+1说明扩容任务完成
// 3.帮助扩容的线程达到了了最大值
// 4.扩容完成的另一种判断 nextTable是空
// 5.transferIndex小于等于0也说明扩容任务完成
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 当前线程加入扩容任务, sc++
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();
}
}
}
fullAddCount
这一段挺难的, 牵扯到了很多种情况
这里的源码注释中建议大家去LongAdder类中看更多解释
// See LongAdder version for explanation
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
// 获取一个随机值
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
if ((as = counterCells) != null && (n = as.length) > 0) {
// 当前的计数盒子中这个下标为空, 表示可以存放一个新的数
if ((a = as[(n - 1) & h]) == null) {
// 判断这个计数器是否被上锁
// 因为cas操作修改了cellsBusy, 保证只有一个线程执行这一个语句块
if (cellsBusy == 0) { // Try to attach new Cell
CounterCell r = new CounterCell(x); // Optimistic create
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
// 一个创建标志
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
// 创建一个新的结点赋值给计数器, 最后finally将cellsBusy赋值为0
// 这一段看上去很像ReentrantLock的上锁解锁过程
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
created = true;
}
} finally {
cellsBusy = 0;
}
// 如果创建成功直接break;
if (created)
break;
// 当前计数器不为空, 后面进入的线程获取了锁
// 但是这个数值已经被前一个线程缩修改了
continue; // Slot is now non-empty
}
}
collide = false;
}
// cas操作已经失败过, 这个变量是addCount传入的, 表示对计数器的累加操作失败
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
// 与addCount中的cas操作一样, 给计数器累加值, 成功就跳出, 失败就往下
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
// 如果有其他线程创建了新的counterCells或者counterCells的容量大于cpu核心数
else if (counterCells != as || n >= NCPU)
collide = false; // At max size or stale
// collide是扩容标志, 如果不允许扩容就会一直在上一步停留, 到了这一步就会允许扩容
// 然后在下一次循环中直接进入扩容步骤
else if (!collide)
collide = true;
// 扩容步骤, cas获取锁, 扩容完毕后, 将扩容标志改为false并重新取一个随机数
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
if (counterCells == as) {// Expand table unless stale
CounterCell[] rs = new CounterCell[n << 1];
for (int i = 0; i < n; ++i)
rs[i] = as[i];
counterCells = rs;
}
} finally {
cellsBusy = 0;
}
collide = false;
continue; // Retry with expanded table
}
h = ThreadLocalRandom.advanceProbe(h);
}
// 由于if中判断的counterCells是空, 所以需要初始化计数盒子, cas获取锁
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
// 初始化成功标志
boolean init = false;
// 初始容量是2, 然后将x放入这个计数盒子
try { // Initialize table
if (counterCells == as) {
CounterCell[] rs = new CounterCell[2];
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
// 计数盒子为空且cellsBusy是1就给baseCount进行cas加操作
// 这里只是做第二次尝试, 如果成功则不需要走计数器
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
transfer
这个方法是扩容的主要方法, 很长
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// 这里的stride用于给线程分配任务, 这里有n个位置需要进行迁移
// 即一个线程需要处理的是transferIndex - stride ~ transferIndex个位置
// 这里根据cpu核心数和n来制定, stride最小为16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
// 初始化, 传入的nextTab如果是空, 说明需要初始化, 新数组比旧数组的容量大一倍
// 这里的初始化由外围调用的方法保证只被初始化一次
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
// 扩容失败, 超出数组最大长度
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
// 这里的transferIndex就是上面说的线程分配任务的标志位
// 任务分配是数组从后往前分配的
transferIndex = n;
}
int nextn = nextTab.length;
// 这里的ForwardingNode的hash值就是前面提到的MOVED, 只要一个结点是ForwardingNode
// 那么其他线程处理到这个结点的时候可以直接跳过
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// advance是一个标志位, 表示迁移能否进行
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
// 从后往前
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// advance为true表示可以进行迁移
// 这里的i可以理解为是指向transferIndex的, 而bound指向transferIndex - stride
while (advance) {
int nextIndex, nextBound;
// 这里就是判断迁移工作是否已经被分配
// 前面说过一个线程完成stride个位置, i如果等于bound说明已经完成了stride个任务
if (--i >= bound || finishing)
advance = false;
// 这里是判断所有的迁移工作是否分配完毕, 因为transferIndex是从后往前的
// 所以如果transferIndex<=0那么就说明所有迁移任务都分配完了了
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 当前线程获取这个stride的任务, 前面判断当前的迁移工作并未被分配
// 所以将transferIndex - stride, 告诉后面线程这个工作我承包了
// 如果transferIndex <= stride就直接将transferIndex 变为0
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// 经过了while循环获取了工作的线程可以开始迁移工作
// 这里三个判断条件都是判断这个i是否符合迁移条件
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// finishing为true表示所有工作已经完成
// 这里进行赋值处理
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 这里用cas对sc-1表示当前线程完成了自己的工作, addCount中有说到sc的作用
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 这里是判断是否所有的迁移工作都已经完成
// 如果不是所有的工作都做完, 那就退出方法
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 说明所有工作都已经完成, 这是最后一个处理任务的线程, 他需要负责赋值的工作
finishing = advance = true;
i = n; // recheck before commit
}
}
// 如果f结点是空, 那么用cas替换将tab[i]进行标记, 直接处理完毕
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 这里表示这个节点已经被处理过
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 开始加锁处理迁移
synchronized (f) {
if (tabAt(tab, i) == f) {
// 接下来的操作跟HashMap中的resize操作极其相似
// 都是将当前的链表一分为二, 一部分放在当前位置i, 一部分放在i+n
// 至于为什么可以这样操作在最后会讲
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);
}
// cas操作替换值
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;
}
}
// 到此为止与链表的操作无异, 也是将结点一分为二生成两个链表
// 这里多了个判断, 如果链表长度<=6, 那么新结点中存放的是链表
// 否则, 判断另一个链表是否为空, 如果是, 不需要重新构造树
// 如果不是, 那么就要重新构造一棵树
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;
}
}
}
}
}
}
这里讲一下链表可以一分为二
假设n是16将要扩容为32
因为16是10000, 存入table中是同1111进行与运算的, 而存入新的table中是同11111进行与运算的
新数组中i存放的数据与i+n存放的数据唯一不同在于第五位二进制数是不是1
如果是1那么就是存放在i+n的 如果是0就是存放在i中的
所以为了判断第五位是不是1, 就可以同16进行与运算如果第五位是0, 那么他们与运算得出的结果就是0
所以可以把这个结点放入lo中, 而结果不为0的就可以存放到i+n中
这个结果跟利用hash值重新同32-1进行与运算得出的结果一致
后记
写完这一篇学习记录之后, 更加清楚了ConcurrentHashMap中这几个方法的用处, 阅读源码真的提升很大, ConcurrentHashMap中的并发设计十分精妙
而这一篇学习记录也仅仅是将put的流程讲述了一遍
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
public native Object getObjectVolatile(Object var1, long var2);
通过以上代码可以看见, tabAt就是使用Unsafe类中的本地方法, 直接从内存中获取这个对象, 使用的是tab的内存地址+索引的偏移量去读取, 可是table和Node中的next在ConcurrentHashMap中本身就是用volatile关键字修饰的, 直接读取也是保证可见性的
所以这个问题无法从这个出发点去解决, 后来阅读了ArrayList的源码之后发现, 数组类在jvm中会自动检测数组的越界问题
对于数组类型，每一维度将使用一个前置的“[”字符来描述，如一个定义为“java.lang.String[][]”类型 的二维数组将被记录成“[[Ljava/lang/String；”，一个整型数组“int[]”将被记录成“[I”。
如果C是一个数组类型，并且数组的元素类型为对象，也就是N的描述符会是类 似“[Ljava/lang/Integer”的形式，那将会按照第一点的规则加载数组元素类型。如果N的描述符如前面所 假设的形式，需要加载的元素类型就是“java.lang.Integer”，接着由虚拟机生成一个代表该数组维度和元 素的数组对象。
上面是深入理解java虚拟机一书中与数组类型有关的内容, 第二段是类加载的解析阶段中所描述的, 所以Node<K, V>[]会先被包装成一个数组类, 所以如果在数组中获取下标为-1的元素会直接抛出异常
这可能会带来一些性能的消耗, 所以这里使用Unsafe直接去操作内存读取可能是出于性能方面的优化考量
扫一扫
497
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
