LongAdder 源码分析

// 可用 CPU 数量
static final int NCPU = Runtime.getRuntime().availableProcessors();
// cell 数组，大小为2的幂次方
transient volatile Cell[] cells;
// 基础偏移值
transient volatile long base;
// 0 无锁 1 有锁
transient volatile int cellsBusy;

@sun.misc.Contended static final class Cell {
    volatile long value;
    Cell(long x) { value = x; }
    final boolean cas(long cmp, long val) {
        return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
    }

    // Unsafe mechanics
    private static final sun.misc.Unsafe UNSAFE;
    private static final long valueOffset;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> ak = Cell.class;
            valueOffset = UNSAFE.objectFieldOffset
                (ak.getDeclaredField("value"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

final void longAccumulate(long x, LongBinaryOperator fn,
                          boolean wasUncontended) {
    int h;
  	// 获取线程的 probe hash值，如果 seed 初始化，probe 为非0
    if ((h = getProbe()) == 0) {
      	// 如果 probe 为0，就强制初始化一次
        ThreadLocalRandom.current(); // force initialization
      	// get 到 probe
        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) {
          	// 通过 hash值获取数组 cells 一个index
            if ((a = as[(n - 1) & h]) == null) {
              	// 当前位置为空，并且拿到锁(cellsBusy 0是无锁，1是有锁)
                if (cellsBusy == 0) {       // Try to attach new Cell
                  	// 构建一个 Cell
                    Cell r = new Cell(x);   // Optimistically create
                  	// casCellsBusy 会把 cellsBuy 设置为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 &&
                                // 计算hash位置j
                                rs[j = (m - 1) & h] == null) {
                              	// 把新构建的 Cell 塞到数组cells的index j的地方
                                rs[j] = r;
                              	// 更新创建完成状态
                                created = true;
                            }
                        } finally {
                          	// free lock
                            cellsBusy = 0;
                        }
                      	// 如果完成直接退出
                        if (created)
                            break;
                      	// 否则继续创建(失败)
                        continue;           // Slot is now non-empty
                    }
                }
              	// 执行到这里说明也是失败(没拿到锁)，设置碰撞标识为false
                collide = false;
            }
          	// hash位置已经有值，则往下走
            else if (!wasUncontended)       // CAS already known to fail
                wasUncontended = true;      // Continue after rehash
          	// 对当前位置累加，例如原本地方的值是1，要加1，现在则为2。成功就退出
            else if (a.cas(v = a.value, ((fn == null) ? v + x :
                                         fn.applyAsLong(v, x))))
                break;
            else if (n >= NCPU || cells != as)
              	// cells 长度大于cpu数量，设置碰撞标识为false
                collide = false;            // At max size or stale
            else if (!collide)
              	// 碰撞标识设置为 true
                collide = true;
          	// 说明前面操作没有成功，再次尝试获取锁进行扩容
            else if (cellsBusy == 0 && casCellsBusy()) {
                try {
                    if (cells == as) {      // Expand table unless stale
                      	// 扩容2倍，然后数组copy
                        Cell[] rs = new Cell[n << 1];
                        for (int i = 0; i < n; ++i)
                            rs[i] = as[i];
                        cells = rs;
                    }
                } finally {
                  	// lock free
                    cellsBusy = 0;
                }
              	// 扩容后重试
                collide = false;
                continue;                   // Retry with expanded table
            }
          	// 重新计算 hash 值
            h = advanceProbe(h);
        }
      	// 1. 初始化 cells，
        else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
            boolean init = false;
            try {                           // Initialize table
                if (cells == as) {
                  	// 最开始容量是2
                    Cell[] rs = new Cell[2];
                  	// hash对应位置赋值
                    rs[h & 1] = new Cell(x);
                    cells = rs;
                    init = true;
                }
            } finally {
                cellsBusy = 0;
            }
            if (init)
                break;
        }
      	// 初始化失败，CAS 把 value 累加到 base
        else if (casBase(v = base, ((fn == null) ? v + x :
                                    fn.applyAsLong(v, x))))
            break;                          // Fall back on using base
    }
}

public void add(long x) {
    Cell[] as; long b, v; int m; Cell a;
  	// cells 为空直接使用 cas 赋值，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 ||
            !(uncontended = a.cas(v = a.value, v + x)))
          	// cas 失败 || cells 不为空 且 index 处为null || cas 再次修改失败
          	// 调用 Striped64 的 longAccumulate
            longAccumulate(x, null, uncontended);
    }
}

public long sum() {
    Cell[] as = cells; Cell a;
  	// 先统计 base的值
    long sum = base;
    if (as != null) {
      	// 再遍历 cells 中的值进行累加
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

public void reset() {
    Cell[] as = cells; Cell a;
    base = 0L;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                a.value = 0L;
        }
    }
}