面试三、多线程之cas/automic

1、CAS

　　1.1、以compareAndSwapInt为例：

　　compareAndSwapInt(ojb, offset, expect, update)，表示在obj对象offset位置的值是否等于expect，如等于则更新为update。

　　1.2、存在问题

　　　　1.2.1、ABA：

　　　　　　第一步、线程1获取内存数据为A

　　　　　　第二步、线程2修改数据为B

　　　　　　第三步、线程2修改数据为A

　　　　　　第四步、线程1进行CAS操作

　　　　　　在第四步中因为内存数据为A，cas操作成功，但其实数据已经被线程2更改过

　　　　　　解决办法：加版本号，每次校验内存值和版本号，只有两者都一致才cas成功。例：AutomicStampedReference

　　　　1.2.2、高竞争下，cas频繁失败一直重试导致开销大

　　　　1.2.3、使用限制条件高，只能保证单个变量操作的原子性　

2、Automic

　　2.1、AutomicInteger/AutomicLong：在并发情况下如果要实现计数器，可以用这两个类来实现。

　　　　以AutomicInteger.getAndAdd()为例：

　　　　AutomicInteger在类加载初始化时会获取value的偏移值设置在valueOffset，value是线程可见的。

　　　　当调用getAndAdd()时，

　　　　27行：先取出value当前的值

　　　　28行：调用cas将value+delta设置进去。如果cas失败说明value值有其他线程改了，自旋一直到成功

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    /**
     * Atomically adds the given value to the current value.
     *
     * @param delta the value to add
     * @return the previous value
     */
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

　　2.2、LongAddr：jdk1.8加入，在并发大的情况下比AutomicLong优秀，代价是占用内存更多。

　　　　引入了连个参数base和cells，base是在竞争不激烈情况下累加值直接更新在base上，当竞争激烈时会根据每个线程的hash来分配cell并将累加值更新在cell里。

　　　　sum+cell[]累计就是总和。设计理念是通过把不同线程分配到不同cell来减少冲突的概率，类似jdk1.7的concurrentHashMap的segment。

　　　　以LongAddr.add()为例

　　　　8行：先尝试cas操作base，如果竞争不激烈则cas直接成功返回

　　　　12行：计算线程hash，如果有对应cell则尝试cas操作cell

　　　　13行：如果cell是空、线程hash没有找到对应cell、cas操作cell失败的情况调用longAccumulate方法

    /**
     * Adds the given value.
     *
     * @param x the value to add
     */
    public void add(long x) {
        Cell[] as; long b, v; int m; Cell a;
        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)))
                longAccumulate(x, null, uncontended);
        }
    }

    /**
     * Returns the current sum.  The returned value is <em>NOT</em> an
     * atomic snapshot; invocation in the absence of concurrent
     * updates returns an accurate result, but concurrent updates that
     * occur while the sum is being calculated might not be
     * incorporated.
     *
     * @return the sum
     */
    public long sum() {
        Cell[] as = cells; Cell a;
        long sum = base;
        if (as != null) {
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

　　　　LongAddr继承了Striped64，引入了base，cells。

　　　　longAccumulate方法：

　　　　32行：如果hash为0，强行实例化一个线程得到hash

　　　　41行：如果hash对应的cell[]坐标为空，则新建一个Cell

　　　　73行：如果cell不够，则扩容cell[]

　　　　最终将线程hash对应的cell上cas加detla

    /**
     * Table of cells. When non-null, size is a power of 2.
     */
    transient volatile Cell[] cells;

    /**
     * Base value, used mainly when there is no contention, but also as
     * a fallback during table initialization races. Updated via CAS.
     */
    transient volatile long base;

    /**
     * Spinlock (locked via CAS) used when resizing and/or creating Cells.
     */
    transient volatile int cellsBusy;
    
    /**
     * Handles cases of updates involving initialization, resizing,
     * creating new Cells, and/or contention. See above for
     * explanation. This method suffers the usual non-modularity
     * problems of optimistic retry code, relying on rechecked sets of
     * reads.
     *
     * @param x the value
     * @param fn the update function, or null for add (this convention
     * avoids the need for an extra field or function in LongAdder).
     * @param wasUncontended false if CAS failed before call
     */
    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) {
                    if (cellsBusy == 0) {       // Try to attach new Cell
                        Cell r = new Cell(x);   // Optimistically create
                        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) {
                                    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
                            Cell[] rs = new Cell[n << 1];
                            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) {
                        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
        }
    }