LongAdder原子操作底层原理

一、LongAdder继承Striped64类

abstract class Striped64 extends Number {
        
        // CPU核数，用来决定cells数组的大小
        static final int NCPU = Runtime.getRuntime().availableProcessors();
    
        // 单元数组，大小为2的次幂
        transient volatile Cell[] cells;
    
        /**
         *  基数，在两种情况下会使用：
         *  1. 没有遇到并发竞争时，直接使用base累加数值
         *  2. 初始化cells数组时，必须要保证cells数组只能被初始化一次（即只有一个线程能对cells初始化），
         *  其他竞争失败的线程会讲数值累加到base上
         */
        transient volatile long base;
    
       /**
        * 自旋锁，通过CAS操作加锁，为0表示cells数组没有处于创建、扩容阶段
        * 为1表示正在创建或者扩展cells数组，不能进行新Cell元素的设置操作
        */
        transient volatile int cellsBusy;
    
 
        // 使用 CAS（Compare And Swap）操作来尝试将对象实例的 BASE 字段从 cmp（期望值）修改为 val（更新值)
        final boolean casBase(long cmp, long val) {
            return UNSAFE.compareAndSwapLong(this, BASE, cmp, val);
        }
    
        // 作用是使用 CAS（Compare And Swap）操作来尝试将 CELLSBUSY 字段的值从 0 修改为 1
        final boolean casCellsBusy() {
            return UNSAFE.compareAndSwapInt(this, CELLSBUSY, 0, 1);
        }
    
        // 获取当前线程的hash值
        static final int getProbe() {
            return UNSAFE.getInt(Thread.currentThread(), PROBE);
        }
        
    }

二、LongAdder原理的直观理解

三、LongAdder的public void add(long x)方法

 public void add(long x) {
      Cell[] as;  //  Striped64类的cells数组
      long b;     //  Striped64类的的base值
      long v;     //  期望值
      int m;      //  cells数组的长度
      Cell a;     //  当前线程命中的cell数组中的cell单元格对象
      if ((as = cells) != null ||   // CASE 1
      !casBase(b = base, b + x)) {  // CASE 2
          boolean uncontended = true;
          if (as == null || (m = as.length - 1) < 0 ||  // CASE 3
              (a = as[getProbe() & m]) == null ||       // CASE 4

              !(uncontended = a.cas(v = a.value, v + x))) // CASE 5
              longAccumulate(x, null, uncontended);
      }
  }

首先介绍一下代码中的外层if块的两个条件语句CASE 1和CASE2：

• 条件语句CASE 1：cells数组不为null，说明存在争用；在不存在争用的时候，cells数组一定为null，一旦对base的cas操作失败，才会初始化cells数组

• 条件语句CASE 2：如果cells数组为null，表示之前不存在争用，并且此次casBase执行成功，表示基于base成员累加成功，add方法直接返回；如果casBase方法执行失败，
  说明产生了第一次争用冲突，需要对cells数组初始化，此时即将进入内层if块。casBase方法很简单，就是通过UNSAFE类的CAS设置成员变量base的值为base+x（要累加的值）

casBase方法的代码如下：

   /**
   * 使用CAS来更新base值
   */
   final boolean casBase(long cmp, long val) {
     return UNSAFE.compareAndSwapLong(this, BASE, cmp,val);
   }

如果add(long x)方法的CASE 1、CASE 2两种条件满足一个，就继续执行内层if语句块，通过Cell元素进行累加，而不是通过base属性
进行累加。接下来介绍add(long x)方法的内层if语句块的三个条件语句CASE3、CASE 4和CASE5：

• 条件语句CASE 3：as==null||(m=as.length-1)<0代表cells没有初始化。

• 条件语句CASE 4：指当前线程的hash值在cells数组映射位置的Cell对象为空，意思是还没有其他线程在同一个位置做过累加操作。

• 条件语句CASE 5：指当前线程的哈希值在cells数组映射位置的Cell对象不为空，然后在该Cell对象上进行CAS操作，设置其值为v+x（x为该Cell需要累加的值），但是CAS操作失败，表示存在争用。

如果以上三个条件语句CASE 3、CASE 4、CASE5有一个为真，就进入longAccumulate()方法。

流程图：

四、LongAdder类中的longAccumulate()方法

longAccumulate()方法的入参：

• long x ：需要做累加的值，increment调用下，一般默认都是+1

• LongBinaryOperator fn ：默认传递的是null

• wasUncontended：竞争标识，如果是false则代表有竞争，只有cells初始化之后，并且当前线程CAS竞争修改失败，才会是false

  final void longAccumulate(long x, LongBinaryOperator fn, boolean wasUncontended) {
      int h;
      // 当前线程还没有对应的 cell, 需要随机生成一个 hash 值用来将当前线程绑定到 cell
      if ((h = getProbe()) == 0) {
          // 初始化 probe，获取 hash 值
          ThreadLocalRandom.current(); 
          h = getProbe();	
          // 默认情况下 当前线程肯定是写入到了 cells[0] 位置，不把它当做一次真正的竞争
          wasUncontended = true;
      }
      // 表示【扩容意向】，false 一定不会扩容，true 可能会扩容
      boolean collide = false; 
      //自旋
      for (;;) {
          // as 表示cells引用，a 表示当前线程命中的 cell，n 表示 cells 数组长度，v 表示 期望值
          Cell[] as; Cell a; int n; long v;
          // 【CASE1】: 表示 cells 已经初始化了，当前线程应该将数据写入到对应的 cell 中
          if ((as = cells) != null && (n = as.length) > 0) {
              // CASE1.1: true 表示当前线程对应的索引下标的 Cell 为 null，需要创建 new Cell
              if ((a = as[(n - 1) & h]) == null) {
                  // 判断 cellsBusy 是否被锁
                  if (cellsBusy == 0) {   
                      // 创建 cell, 初始累加值为 x
                      Cell r = new Cell(x);  
                      // 加锁
                      if (cellsBusy == 0 && casCellsBusy()) {
                          // 创建成功标记，进入【创建 cell 逻辑】
                          boolean created = false;	
                          try {
                              Cell[] rs; int m, j;
                              // 把当前 cells 数组赋值给 rs，并且不为 null
                              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)			// true 表示创建完成，可以推出循环了
                              break;
                          continue;
                      }
                  }
                  collide = false;
              }
              // CASE1.2: 条件成立说明线程对应的 cell 有竞争, 改变线程对应的 cell 来重试 cas
              else if (!wasUncontended)
                  wasUncontended = true;
              // CASE 1.3: 当前线程 rehash 过，如果新命中的 cell 不为空，就尝试累加，false 说明新命中也有竞争
              else if (a.cas(v = a.value, ((fn == null) ? v + x : fn.applyAsLong(v, x))))
                  break;
              // CASE 1.4: cells 长度已经超过了最大长度 CPU 内核的数量或者已经扩容
              else if (n >= NCPU || cells != as)
                  collide = false; 		// 扩容意向改为false，【表示不能扩容了】
              // CASE 1.5: 更改扩容意向，如果 n >= NCPU，这里就永远不会执行到，case1.4 永远先于 1.5 执行
              else if (!collide)
                  collide = true;
              // CASE 1.6: 【扩容逻辑】，进行加锁
              else if (cellsBusy == 0 && casCellsBusy()) {
                  try {
                      // 线程安全的检查，防止期间被其他线程扩容了
                      if (cells == as) {     
                          // 扩容为以前的 2 倍
                          Cell[] rs = new Cell[n << 1];
                          // 遍历移动值
                          for (int i = 0; i < n; ++i)
                              rs[i] = as[i];
                          // 把扩容后的引用给 cells
                          cells = rs;
                      }
                  } finally {
                      cellsBusy = 0;	// 解锁
                  }
                  collide = false;	// 扩容意向改为 false，表示不扩容了
                  continue;
              }
              // 重置当前线程 Hash 值，这就是【分段迁移机制】
              h = advanceProbe(h);
          }
  
          // 【CASE2】: 运行到这说明 cells 还未初始化，as 为null
          // 判断是否没有加锁，没有加锁就用 CAS 加锁
          // 条件二判断是否其它线程在当前线程给 as 赋值之后修改了 cells，这里不是线程安全的判断
          else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
              // 初始化标志，开始 【初始化 cells 数组】
              boolean init = false;
              try { 
                 	// 再次判断 cells == as 防止其它线程已经提前初始化了，当前线程再次初始化导致丢失数据
                  // 因为这里是【线程安全的，重新检查，经典 DCL】
                  if (cells == as) {
                      Cell[] rs = new Cell[2];	// 初始化数组大小为2
                      rs[h & 1] = new Cell(x);	// 填充线程对应的cell
                      cells = rs;
                      init = true;				// 初始化成功，标记置为 true
                  }
              } finally {
                  cellsBusy = 0;					// 解锁啊
              }
              if (init)
                  break;							// 初始化成功直接跳出自旋
          }
          // 【CASE3】: 运行到这说明其他线程在初始化 cells，当前线程将值累加到 base，累加成功直接结束自旋
          else if (casBase(v = base, ((fn == null) ? v + x :
                                      fn.applyAsLong(v, x))))
              break; 
      }
  }
  

longAccumulate的自旋过程中，有三个大的if分支：

• CASE1：表示cells已经初始化了，当前线程应该将数据写入对应的Cell中。

• CASE2：cells还未初始化（as为null），本分支计划初始化cells，在此之前开始执行cellsBusy加锁，并且要求cellsBusy加锁成功。

• CASE3：如果cellsBusy加锁失败，表示其他线程正在初始化cells，所以当前线程将值累加到base上。

CASE1表示当前线程应该将数据写入对应的Cell中，又分为以下几种细分情况：

• CASE1.1：表示当前线程对应的下标位置的Cell为null，需要创建新Cell。

• CASE1.2：wasUncontended是add(…)方法传递进来的参数如果为false，就表示cells已经被初始化，并且线程对应位置的Cell元素也已经被初始化，但是当前线程对Cell元素的竞争修改失败。如果add方法中的条件语句CASE 5通过CAS尝试把cells[m%cells.length]位置的Cell对象的value值设置为v+x而失败了，就说明已经发生竞争，就将wasUncontended设置为false。如果wasUncontended为false，就需要重新计算prob的值，那么自旋操作进入下一轮循环。

• CASE 1.3：无论执行CASE1分支的哪个子条件，都会在末尾执行h=advanceProb()语句rehash出一个新哈希值，然后命中新的Cell，如果新命中的Cell不为空，在此分支进行CAS更新，将Cell的值更新为a.value+x，如果更新成功，
  就跳出自旋操作；否则还得继续自旋。

• CASE 1.4：调整cells数组的扩容意向，然后进入下一轮循环。如果n≥NCPU条件成立，就表示cells数组大小已经大于等于CPU核数，扩容意向改为false，表示不扩容了；如果该条件不成立，就说明cells数组还可以扩容，尽管如此，
  如果cells != as为true，就表示其他线程已经扩容过了，也会将扩容意向改为false，表示当前循环不扩容了。当前线程调到CASE1分支的末尾执行rehash操作重新计算prob的值，然后进入下一轮循环。

• CASE 1.5：如果!collide=true满足，就表示扩容意向不满足，设置扩容意向为true，但是不一定真的发生扩容，然后进入CASE1分支末尾重新计算prob的值，接着进入下一轮循环。

• CASE 1.6：执行真正扩容的逻辑。其条件一cellsBusy==0为true表示当前cellsBusy的值为0（无锁状态），当前线程可以去竞争这把锁；其条件二casCellsBusy()表示当前线程获取锁成功，CAS操作cellsBusy改为0成功，可以执行扩容逻辑。

流程图：

五、LongAdder类的casCellsBusy()方法

casCellsBusy()方法的代码很简单，就是将cellsBusy成员的值改为1，表示目前的cells数组在初始化或扩容中，具体的代码如下：

final boolean casCellsBusy() {
   return UNSAFE.compareAndSwapInt(this, CELLSBUSY, 0,1);
}

casCellsBusy()方法相当于锁的功能：当线程需要cells数组初始化或扩容时，需要调用casCellsBusy()方法，通过CAS方式将cellsBusy成员的值改为1，如果修改失败，就表示其他的线程正在进行数组初始化或扩容的操作。只有CAS操作成功，cellsBusy成员的值被改为1，当前线程才能执行cells数组初始化或扩容的操作。在cells数组初始化或扩容的操作执行完成之后，cellsBusy成员的值被改为0，这时不需要进行CAS修改，直接修改即可，因为不存在争用。当cellsBusy成员值为1时，表示cells数组正在被某个线程执行初始化或扩容操作，其他线程不能进行以下操作：

• 对cells数组执行初始化。
• 对cells数组执行扩容。
• 如果cells数组中某个元素为null，就为该元素创建新的Cell对象。因为数组的结构正在修改，所以其他线程不能创建新的Cell对象。