LongAdder理解

LongAdder是对Long类型字段进行多线程累加的工具类，在线程竞争较多后，LongAdder比AutomicLong更有效率；
AutomicLong 当调用自增方法时，是使用cas + 自旋的方式 实现的；相对慢的原因是，仅对 valueoddSet 进行操作；

	public final long incrementAndGet() {
        return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
    }
    public final long getAndAddLong(Object var1, long var2, long var4) {
        long var6;
        do {
            var6 = this.getLongVolatile(var1, var2);
        } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

        return var6;
    }

而 LongAdder 的思想则是，构建一个数组，对每个线程进行hash，这些线程分别去操作hash后对应的数组元素；这样就可以减少竞争；理论上并发线程的个数有上限，所以数组的大小也会有上限；

数组元素cell的防止伪共享

数组中的元素类型是Cell;一个Cell 对象占用一个缓存行，64B；

@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);
            }
        }
    }

cas base

并发发生之初，仅有第一个线程到来，来进行累加时；只需要对base 进行cas操作就行；

transient volatile long base;

初始化数组逻辑

cas 一次失败，获取到锁，会立刻初始化数组；

/**
** 数组操作锁，cas 由0->1 成功，则获取锁，由1->0成功，则释放锁
*/
transient volatile int cellsBusy;
// 初始化数组逻辑
else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
                boolean init = false;
                try {                           // Initialize table
                    if (cells == as) {
                        Cell[] rs = new Cell[2];
                        rs[h & 1] = new Cell(x);
                        cells = rs;
                        init = true;
                    }
                } finally {
                    cellsBusy = 0;
                }
                if (init)
                    break;
 }

数组的扩容，与数组尚未初始化完成前

数组初始化之后，再进行累加时，发现数组已经被初始化了，则先对线程进行hash,找到对应数组中的元素；hash方法是根据线程的probe 与数组长度n-1 进行与操作，然后对数组元素 cell 的 value 进行 一次 cas 操作；
cas 成功，说明没有竞争冲突，则累计成功，操作结束；cas 失败，则需要进一步判断 - 跟踪 2.x 注释的步骤；
再来一个线程，hash 后定位数组元素为null （是因为别的线程进行了扩容）,进一步判断 - 跟踪3.x注释的步骤
再来一个线程，和初始化线程不同的地方在于，它进行加法时，cells为空，但casBase失败；- 跟踪 4.x的注释

    public void add(long x) {
        Cell[] as; long b, v; int m; Cell a;
        // 数组 cells 未初始化前，进行 casBase 操作;否则进行数组元素值的 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 失败则继续判断
                longAccumulate(x, null, uncontended);
        }
    }

该方法中包含获取线程的 probe的值（可以理解为线程的某一种hash）

 final void longAccumulate(long x, LongBinaryOperator fn,
                              boolean wasUncontended) {
        // 获取线程的hash值
        int h;
        if ((h = getProbe()) == 0) {
            ThreadLocalRandom.current(); // force initialization
            h = getProbe();
            wasUncontended = true;
        }
        boolean collide = false;                // True if last slot nonempty
        // for 循环，一种自旋的形式；再高并发场景下，任何一个在执行的线程都会进行无限次的尝试，减少线程的切换就
        for (;;) {
            Cell[] as; Cell a; int n; long v;
            // 2.1，3.1 按照我们的思路，此时cells 已经初始化，且 n > 0,进入该分支
            // 4.1 cess 为null 不进入该分支
            if ((as = cells) != null && (n = as.length) > 0) {
                // 2.2 按照我们的逻辑，此时 cell 的 cas 操作已经失败，则不进入该分支
                // 3.2 别的线程扩容后，新来的线程分配到一个未初始化的cell
                if ((a = as[(n - 1) & h]) == null) {
                    // 3.3 查看是否有线程进行数组操作，如果没有人进行数组操作，则我们去初始化该cell
                    if (cellsBusy == 0) {       // Try to attach new Cell
                    	// 创建一个新的cell
                        Cell r = new Cell(x);   // Optimistically create
                        // 3.3.1再次检查锁是否被持有，并获取锁
                        if (cellsBusy == 0 && casCellsBusy()) {
                            boolean created = false;
                            // 3.3.2 再获取到锁后再次检查是否可以将刚才创建的cell赋值给对应的数组元素
                            try {               // Recheck under lock
                                Cell[] rs; int m, j;
                                if ((rs = cells) != null &&
                                    (m = rs.length) > 0 &&
                                    rs[j = (m - 1) & h] == null) {
                                    rs[j] = r;
                                    created = true;
                                }
                            } finally {
                                cellsBusy = 0;
                            }
                            // 3.3.3 如果创建成功，则代表加法已经成功，跳出循环；若未成功，则继续下一次循环；
                            if (created)
                                break;
                             // 3.3.4 可能是别的线程赋值了该cell;也可能是别的线程赋值别的cell;也可能是别的线程再次扩容了
                            continue;           // Slot is now non-empty
                        }
                    }
                    // 3.4 未获得获取锁的资格，进行下一次循环
                    collide = false;
                }
                // 2.3 我们知道已经发生冲突了，则进入该分支，更改并发标志，继续下一次循环
                else if (!wasUncontended)       // CAS already known to fail
                    wasUncontended = true;      // Continue after rehash
                // 2.4 再一次循环来到这里，再次 cas ;cas 成功，则结束；cas 失败则继续判断下一个分支
                else if (a.cas(v = a.value, ((fn == null) ? v + x :
                                             fn.applyAsLong(v, x))))
                    break;
                // 2.5. 是否可扩容，当已经发生扩容或者不能再扩容时，就认为未发生碰撞;继续下一次循环；否则去尝试2.7的扩容
                else if (n >= NCPU || cells != as)
                    collide = false;            // At max size or stale
                // 2.6 未发生碰撞，但实际上是发生冲突了；继续下一次循环，进项cas cell
                else if (!collide)
                    collide = true;
                // 2.7尝试持有数组操作的cas锁
                else if (cellsBusy == 0 && casCellsBusy()) {
                    try {
                    	// 2.7.1 别的线程没有扩容，则扩容两倍；别人已经扩容，则继续下一次循环
                        if (cells == as) {      // Expand table unless stale
                            Cell[] rs = new Cell[n << 1];
                            for (int i = 0; i < n; ++i)
                            	// 之前的元素仍放在对应的位置
                                rs[i] = as[i];
                            cells = rs;
                        }
                    } finally {
                    	// 2.7.2 释放锁
                        cellsBusy = 0;
                    }
                    collide = false;
                    continue;                   // Retry with expanded table
                }
                // 2.8 如果未获取到数组锁，代表别的线程对数组进行了扩容，重新hash 后再次循环
                h = advanceProbe(h);
            }
            // 4.2 cellsBusy锁 被正在初始化的线程持有着，所以也不进入该分支
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
                boolean init = false;
                try {                           // Initialize table
                    if (cells == as) {
                        Cell[] rs = new Cell[2];
                        rs[h & 1] = new Cell(x);
                        cells = rs;
                        init = true;
                    }
                } finally {
                    cellsBusy = 0;
                }
                if (init)
                    break;
            }
            // 4.3 再一次cas base操作，操作成功，则直接返回；操作失败，再进行下一次循环
            else if (casBase(v = base, ((fn == null) ? v + x :
                                        fn.applyAsLong(v, x))))
                break;                          // Fall back on using base
        }
    }

竞争最激烈（碰撞最多的cell）扩容数组

如上面注释2.x步骤所示，首先cell 不为空，进行 cas cell 操作；失败，则进入循环里，再一次 cas cell；失败，则判断是否可扩容，或者别的线程是否已经扩容了；若不可扩容，则始终进行循环cas cell;如果可以扩容，获取到锁进行扩容，然后继续下一次 cas cell;如果可以扩容，但未成功获取锁，则重新hash 获取新的cell(也可能不是新的)，进行cas cell 操作；

总结

写这篇博客的原因，是想深入理解对热点key的分解思想，学习具体的实现思路；代码初次看起来，挺难懂，实际上却很清晰，简介，逻辑缜密，实现巧妙；