源码—原子类，，内存屏障，缓存伪共享与

public final int getAndUpdate {    int prev, next;    do { prev = get; next = updateFunction.applyAsInt;    } while );    return prev;}

和updateAndGet类似，返回的是旧值

1.1.9lazySet

java

public final void lazySet {    unsafe.putOrderedInt;}

lazySet提供一个store store屏障，但是没有store load屏障，我的理解是把volatile的写后store load替换成了store store，Store load屏障可以让后续的load指令对其他处理器可见，但是需要将其他处理器的缓存设置成无效让它们重新从主层读取，store store，是保证后续处理器在写volatile变量的时候可以看见lazyset方法改变的值，但是后续的读不保证一定可见，但是对于volatile变量的读自然是会读到最新值的，从而减少了开销。lazySet的lazy 意味着最终数据的一致性，但是当前是进行了偷懒的

2.AtomicBoolean

源码基本上和AtomicInteger类似，但是并不是底层存的布尔类型，而是使用int类型，0代表false，1代表true

3.AtomicLong

和AtomicInteger类似

2.原子更新数组

AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray的原理类似，数组类型更新的问题在于，我要更新下标为i的元素，我怎么知道i这个元素的地址。如果我们知道第一个元素相对于对象的偏移base，和每个元素的偏移s，那么第i个元素就是base+i*s

java

private static final int base = unsafe.arraybaseOffset;private static final int shift; static { //每个元素的大小 int scale = unsafe.arrayIndexScale; //必须是2的n次幂 if ) != 0)     throw new Error; //每个元素大小为4 那么第n个大小偏移就是n*4 也就是n<<2//shift 是31 -  scale的前导0 方便后续进行位移操作获取第n个元素相对于第一个的偏移量 shift = 31 - Integer.numberOfLeadingZeros;    }

2.1计算第i个元素的位置

java

//前置检查private long checkedByteOffset {    if  throw new IndexOutOfBoundsException;    return byteOffset;}//第n个元素的位置//i*4+base==> i<<2 + baseprivate static long byteOffset {    return  i << shift) + base;}

2.2 获取和设置

java

public final int get {    return getRaw);}private int getRaw {    //调用getIntVolatile 保证了可见性     return unsafe.getIntVolatile;}//同样设置也是调用putIntVolatilepublic final void set {    unsafe.putIntVolatile, newValue);}

其他方法和AtomicInteger中大差不大都是调用Unsafe中的相关方法

3.原子更新引用

AtomicReference还是老套路，不多赘述

3.1 原子更新引用的一个字段

AtomicReferenceFieldUpdater 是一个抽象类，使用的时候必须调用newUpdater来获取它的实现AtomicReferenceFieldUpdaterImpl后续的更新也是调用unsafe的cas相关操作

3.2 原子的更新引用和布尔标记

AtomicMarkableReference可以同时更新引用和引用的标记，上面我们提到CAS的一个缺点——ABA问题，比如说，当前商店存在一个活动，如果账户办理冲一百送50，每个账户依次机会，A用户充值后获得150元立马消费成0元接着充值100，如果用普通的原子类AtomicInteger程序还会再次送50元给用户A，我们可以使用锁充值后获取锁往集合里面记录当前用户赠送了，也可以使用AtomicMarkableReference通过更新mark来记录用户赠送过了

AtomicMarkableReference内部维护了一个Pair，并且private volatile Pair pair 持有一个pair

3.2.1compareAndSet

java

public boolean compareAndSet {    //当前AtomicMarkableReference 中的 Pair 记录引用和 标记    Pair current = pair;    return //旧引用和Pair中引用相同，旧标记和Pair中的标记相同 expectedReference == current.reference && expectedMark == current.mark   && //这里是且 //新引用相同 且 新标记相同    || //这里是或    //CAS修改pair属性  casPair));}

也就是说，首先要求旧值是和当前pair相同的，如果修改之前被其他线程修改了那么短路返回false，如果引用从始至终都没改变，那么都不需要CAS操作，否则CAS pair属性，下面是casPair的源码——还是老套路

java

private boolean casPair {    return UNSAFE.compareAndSwapObject;}

3.2.2 attemptMark

java

public boolean attemptMark {    Pair current = pair;    return expectedReference == current.reference && ));}

和compareAndSet的区别在于，其只要求引用相同，如果mark相同那么什么都不做,反之CAS修改pair

3.3 原子的更新引用和版本号

AtomicStampedReference也是用来解决ABA问题的，不同的是其标记不只是true和false，可以是1，2，3等等等版本号，我们把AtomicMarkableReference中活动改下，每一个账户可以参与3次活动，那么在充值的时候我们把版本号加1，最后版本号来到3 表示这个账户参与了3次，后续充值就不赠送了。

AtomicStampedReference 实现和AtomicMarkableReference简直一模一样，区别在于AtomicStampedReference中Pair类是引用和版本号

4.累加器

上面我们提到CAS的缺点说到存在热点数据更新导致多数线程失败自旋的问题，其中一个解决办法是自旋次数，失败就返回活动太火爆这种劝退消息，另外一种解决办法是——热点数据拆分开，最后再汇总。这个思路和ConcurrentHashMap的分段锁思路类似，既然我如同HashTable导致性能低下那么我把数据，不同的数据使用不同的锁，就可以提高吞吐量了。在累加器中的体现就是，在最初无竞争时，只更新base的值，当有多线程竞争时通过分段的思想，让不同的线程更新不同的段，最后把这些段相加就得到了完整存储的值。

none

累加器的思路都类似，我们选择LongAdder 和 LongAccumulator来看下

4.1 LongAdder

4.1.1 LongAdder的内部结构

LongAdder 内部有base用于在没有竞争的情况下，进行CAS更新，其中还有Cell数组在冲突的时候根据线程唯一标识对Cell数组长度进行取模，让线程去更新Cell数组中的内容。这样最后的值就是 base+Cell数组之和，LongAdder自然只能保证最终一致性，如果边更新边获取总和不能保证总和正确。

4.1.2 LongAdder的继承关系

这里比较迷惑的就是Striped64这个类，此类是一个内部类，用于实现 Adder 和 Accumulator，我们上面所说的base,Cell数组其实就是在此类中的。

4.1.3 LongAdder 源码解析

4.1.3.1Cell 类

此类位于Striped64中，就是我们上面说的Cell数组进行热点数据分离的Cell

java

@sun.misc.Contended static final class Cell {    volatile long value;    Cell { value = x; }    final boolean cas { return UNSAFE.compareAndSwapLong;    }    //老套路 unsafe    private static final sun.misc.Unsafe UNSAFE;    //value 字段的偏移量    private static final long valueOffset;    static { //初始化 获取unsafe 实例 以及获取value 偏移量 try {     UNSAFE = sun.misc.Unsafe.getUnsafe;     Class< > ak = Cell.class;     valueOffset = UNSAFE.objectFieldOffset  ); } catch  {     throw new Error; }    }}

Cell 这个类还是老套路，唯一不同的是它类上面具有一个注解 @sun.misc.Contended此注解会进行缓存填充，避免缓存伪共享 ；

4.1.3.2 Striped64中的属性

NCPU 记录了系统 CPU 的核数，因为真正的并发数最多只能是 CPU 核数，因此 cells 数组一般要大于这个数。

cells 数组，大小是 2 的次方，这样将线程映射到 cells 元素时方便计算。

base，基本数值，一般在无竞争能用上，同时在 cells 初始化时也会用到。

cellsBusy，自旋锁，在创建或扩充 cells 时使用

4.1.3.3 LongAdder #void add

java

public void increment {    add;}public void decrement {    add;}//LongAdder中增大和减小都是直接调用的add 方法

java

public void add {    //as ——Cells数组的引用    //b 获取到的base值    //v 期望值    //m 标识Cells数组的长度-1    //a 标识当前线程命中的Cell单元格    Cell[] as; long b, v; int m; Cell a; //如果 cells数组初始化了    //  或者 cas的修改base值 失败了 if  != null || !casbase) { //没有发生冲突的标识 boolean uncontended = true; //as == null ||  < 0  表示如果cell数组为空  if  < 0 ||     //或者当前线程的cell单元没有初始化      & m]) == null ||     //或者cas修改base失败了     !))   longAccumulate;    }}

A.对于第一个if

从来没有发生过竞争

并发量很低的时候Cell数组就是空，这个时候第一个if中的 != null就是false 会继续执行后续的!casbase这一步会cas的更新bese 值

如果cas更新base成功了，那么皆大欢喜，直接结束了，说明当前并发还是很低

如果cas 更新失败，说明这一瞬间有多个线程都在更新base值，并发比较高，当前线程是一个倒霉蛋，cas更新没有抢过别人。这个时候会进入到 if代码块中

之前发生过竞争

这个时候第一个if的 != null就成立了 ,不会走第一个if中的cas操作，直接进入第二个if

B.对于第二个if

进入第二个if，当前线程需要把值更新到对应的cell中

as == null || < 0 这意味着cell数组没有初始化，也就是说这是第一次存在高并发竞争的情况，那么调用longAccumulate 这个方法会帮我们初始化cell数组的

& m]) == null 这意味着，cell数组初始化了，但是当前线程标识取模数组长度得到当前线程应该更新的cell为空

如果当前线程所属的Cell为空，那么也会调用longAccumulate

这里我们要关注一点getProbe 方法初始的时候都是0，0取模任何数都是0那么每一个线程最开始都会分配第一个Cell，那么第一个Cell为空意味着什么昵，这个问题需要我们看完longAccumulate 方法才能揭晓其实probe=0在longAccumulate方法中意味着当前线程没有和其他线程发生冲突更新在longAccumulate 会初始化probe 设置冲突更新表示为false

longAccumulate 方法非常长，我们拆看慢慢看

//如果是0 表示没有是没有初始化的//这里会为当前线程生成一个probeif ) == 0) {    ThreadLocalRandom.current; // force initialization    h = getProbe;    //设置为没有竞争，    wasUncontended = true;}

else if ) {    //是否完成了初始化    boolean init = false;    try {      //==========代码点1==============   //确认没有其他老六抢先初始化  if  {     // 初始化     Cell[] rs = new Cell[2];//选择一个格子 设置为x，probe奇数那么选择rs[1] 反之rs[0]     rs[h & 1] = new Cell;     cells = rs;     init = true; }    } finally { //释放锁 cellsBusy = 0;    }    //如果成功初始化 那么结束    if  break;}

//使用位操作，把当前线程的probe随机打散，为啥这里这样进行位操作//我只能说，可能时doug lea研究后的，或者他喜欢这个几个数字//但是这几个数组都是质数，大概率后面是存在理论支撑的，static final int advanceProbe {    probe ^= probe << 13;   // xorshift    probe ^= probe >>> 17;    probe ^= probe << 5;    UNSAFE.putInt, PROBE, probe);    return probe;}

再次给看跪了，doug lea真性能狂魔

//as——cells数组引用//a 当前线程对于的cell//n 当前数组长度//v 期望值//h 当前线程的threadLocalRandomProbe//x是当前线程要增加的值Cell[] as; Cell a; int n; long v;//如果cells初始化了if  != null &&  > 0) {    //如果当前线程threadLocalRandomProbe取模后对于的cell为空 //==========代码点1==============    if  & h]) == null) { //cellsBusy是一个自旋锁保证Cell数组的线程安全 //0代表无线程调整Cell数组大小or或创建单元格 //1 则反之 //==========代码点2============== if  {   //为当前线程创建一个cell，     //x直接赋值给其中的value 后续求和会加上这个x，从而实现增加     Cell r = new Cell;      //0代表无线程调整Cell数组大小or或创建单元格     //casCellsBusy 是从0设置成1 表示当前线程尝试获取这把锁      //==========代码点3==============     if ) {  boolean created = false;  try {     Cell[] rs; int m, j;      //重新判断cell数组初始化了，且当前cell是空      //看下方解析为何需要重新     //==========代码点4==============      if  != null &&    > 0 &&   rs[j =  & h] == null) {   //设置到cell数组上   rs[j] = r;   created = true;      }  } finally {      //释放锁      cellsBusy = 0;  }    //如果这里成功创建了cell，说明成功把值加上去了  //那么退出自旋  ifbreak;  continue;    // Slot is now non-empty     } } collide = false; //....省略部分代码，这部分也会在后续解析  //重新刷新当前线程的Probe //==========代码点5============== h = advanceProbe;    }

if  != null &&  > 0) {    if  & h]) == null) {//省略了情况1的代码    }    else if // CAS already known to fail wasUncontended = true;  //....省略部分代码，这部分也会在后续解析      //重新刷新当前线程的Probe      h = advanceProbe;

public void add {    Cell[] as; long b, v; int m; Cell a;    if  != null || !casbase) { //初始为true  boolean uncontended = true; if  < 0 ||      & m]) == null ||   //注意这里     !))     //要让uncontended为false     //那么说明上面的a.cas失败了     longAccumulate    }}

if  != null &&  > 0) {    //省略讲过的代码。。。 // 成功把值增加到对应的cell  else if    v + x : fn.applyAsLong)))//自旋结束 break;

@FunctionalInterfacepublic interface LongBinaryOperator {    long applyAsLong;}

if  != null &&  > 0) {//省略讲过的代码。。。    //==========代码点1==============  //collide 表示扩容的意向，为true并不代表一定会扩容 //如果cell数组的长度大于了jvm可以使用的核心数 或者cells数组引用改变了 else ifcollide = false;    //==========代码点2============== else if collide = true;     //拿到cellsBusy这把锁 else if ) { try {     //判断下cells引用没有改变      //==========代码点3==============if  {//扩容 扩大1倍    Cell[] rs = new Cell[n << 1];forrs[i] = as[i];    //改变cells应用指向cells = rs;  }    } finally {     //释放锁cellsBusy = 0;     }      //扩容意向为false     collide = false;     continue;  } //rehash probe  h = advanceProbe;}

 else if    v + x :     fn.applyAsLong)))  break;

public long sum {    Cell[] as = cells; Cell a;    long sum = base;    if  { for  {     if  != null)  sum += a.value; }    }    return sum;}

public void reset {    Cell[] as = cells; Cell a;    base = 0L;    if  { for  {     if  != null)  a.value = 0L; }    }}

    public long sumThenReset { Cell[] as = cells; Cell a; long sum = base; base = 0L; if  {     for  {  if  != null) {      sum += a.value;      a.value = 0L;  }     } } return sum;    }

public LongAccumulator {    this.function = accumulatorFunction;    base = this.identity = identity;}

public void accumulate {Cell[] as; long b, v, r; int m; Cell a;//cell数组没有初始化if  != null || ) != b && !casbase) { boolean uncontended = true; //cell数组没有初始化 if  < 0 ||  & m]) == null || !) == v ||//或cas失败a.cas))   //这里传入了 function 在 longAccumulate中就不是简单的自增了     longAccumulate;    }}

public long get { Cell[] as = cells; Cell a; long result = base; if  { for  { if  != null)   result = function.applyAsLong;    }     }     return result;    }

@sun.misc.Contended static final class Cell {volatile long value;//省略部分代码}

public static void main {test2;}private static void test2 { Long1 long1 = new Long1; CountDownLatch latch = new CountDownLatch; long start = System.currentTimeMillis; new Thread -> {for  {long1.l1++;}      latch.countDown; }).start;     new Thread -> {    for  { long1.l2++;    }    latch.countDown; }).start;     try {  latch.await;  long end = System.currentTimeMillis; System.out.println; } catch  { }} @Contended    static class Long1 {     private volatile long l1;     private volatile long l2;    }