分段锁的应用（JUC Map，LongAdder）
分段锁的应用
分段锁顾名思义就是只锁一段而不是全局的加锁，有效提高了在多线程情况下的速度
1.ConcurrentHashMap
ConcurrentHashMap之所以效率高又是线程安全的，主要是使用了分段锁和cas，很多文章都有不细说了
使用了分段锁的代码段：
//这里锁的就是数组中的单向链表或红黑树的头结点,put时hash到不同的数组中的链表锁的对象是不同的可以实现并行put,只有被分配到同一个链表的时候需要阻塞
synchronized (f) {
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;
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;
}
2.LongAdder
LongAdder是在1.8之后才新加入juc里的工具，里面有一个cell数组，cell是在Striped64中的静态内部类，每个cell维护自己的value，AtomicInteger中仅维护一个全局的value，调用sum将所有cell的value和base相加就是最终的值
先看一下Add方法
public void add(long x) {
Cell[] as; long b, v; int m; Cell a;
//如果cell是空未被初始化
//就执行!casBase(b = base, b + x)
//这里的base就相当于AtomicInteger中全局的value
//cas设置成功就结束，设置失败说明有竞争，进入方法体
if ((as = cells) != null || !casBase(b = base, b + x)) {
boolean uncontended = true;
//做了一些判断
if (as == null || (m = as.length - 1) < 0 ||
(a = as[getProbe() & m]) == null ||
//cas设置cell的value值，如果设置是失败进入方法体
//uncontended会变为false
!(uncontended = a.cas(v = a.value, v + x)))
longAccumulate(x, null, uncontended);
}
}
下面就是核心的方法
final void longAccumulate(long x, LongBinaryOperator fn,
boolean wasUncontended) {
int h;
if ((h = getProbe()) == 0) {
ThreadLocalRandom.current(); // force initialization
h = getProbe();
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
for (;;) {
Cell[] as; Cell a; int n; long v;
if ((as = cells) != null && (n = as.length) > 0) {
//坑里是空的话
if ((a = as[(n - 1) & h]) == null) {
//cellsBusy 0代表可以获取锁
if (cellsBusy == 0) { // Try to attach new Cell
//把add的值放入cell的value中
Cell r = new Cell(x); // Optimistically create
//cellsBusy 锁标识位如果是0 并且cas将0改为1成功的话
if (cellsBusy == 0 && casCellsBusy()) {
boolean created = false;
try { // Recheck under lock
Cell[] rs; int m, j;
if ((rs = cells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) { //一顿判断之后把cell放入坑里
rs[j] = r;
//结束表示位
created = true;
}
} finally {
//释放锁
cellsBusy = 0;
}
if (created)
break;
//如果坑不够了，或者坑里有人了就继续循环跳到下面扩容的代码段，扩容完不会直接丢进去需要再次循环进到上面这个代码段里
continue; // Slot is now non-empty
}
}
collide = false;
}
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
else if (a.cas(v = a.value, ((fn == null) ? v + x :
fn.applyAsLong(v, x))))
break;
else if (n >= NCPU || cells != as)
collide = false; // At max size or stale
else if (!collide)
collide = true;
else if (cellsBusy == 0 && casCellsBusy()) {
try {
if (cells == as) { // Expand table unless stale //扩容2倍
Cell[] rs = new Cell[n << 1];
//n是原始cell数组长度，按原始下表移动到新数组
for (int i = 0; i < n; ++i)
rs[i] = as[i];
cells = rs;
}
} finally {
cellsBusy = 0;
}
collide = false;
continue; // Retry with expanded table
}
h = advanceProbe(h);
}
//获取锁
else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
boolean init = false;
try { // Initialize table
if (cells == as) {
//初始化为2的整数倍
Cell[] rs = new Cell[2];
rs[h & 1] = new Cell(x);
cells = rs;
init = true;
}
} finally {
//释放锁
cellsBusy = 0;
}
if (init)
break;
}
else if (casBase(v = base, ((fn == null) ? v + x :
fn.applyAsLong(v, x))))
break; // Fall back on using base
}
}