并发编程实战14-LongAdder统计加法器-计数器jdk8

传统的原子锁AtomicLong/AtomicInt虽然也可以处理大量并发情况下的计数器,但是由于使用了自旋等待,当存在大量竞争时,会存在大量自旋等待,而导致CPU浪费,而有效计算很少,降低了计算效率。

而LongAdder是根据ConcurrentHashMap这类为并发设计的类的基本原理——锁分段,通过维护一个计数数组cells来保存多个计数副本,每个线程只对自己的副本进行操作,最后汇总来得到最终结果。

Adder的英文意思为加法器,从字面意思上就可以理解,LongAdder的作用是用来进行统计计算的。比如,我们需要一个计数器,加入计数值为N,当大量的线程访问时,N的值将会出现并发安全,但是,我们并不打算在每个单独的子线程中去查看这个N值,只是在所有的子线程完毕后,才会统计N的总数,即相当于一种并行计算,但是我们不在乎中间结果,只在乎,中间计算都进行了就可以。因此,我们对可以变量创建一个副本N’,每个线程都有这个副本,只对这个副本进行操作,最后,将所有的副本进行汇总就是最终的N值,即:N=N1'+N2'+N3'...+Nn'

详细原理:内部源码使用了一个cells的数组来保存每个线程的副本,第一个线程会初始化数组cells。新来到一个线程,会指向第一个cell,并检测是否有其他线程使用CAS,如果没有,则所有线程公用一个cel副本;否则,如果自旋等待,则当前线程新建一个cell副本,加入到数组cells,对副本进行操作。当所有操作完成后,使用sum函数就可以统计所有的操作。

这里也用到了cas操作,主要是为了防止多线程公用一个cell,导致一个cell数据并发出错,另外注意LongAdder的并不是细粒度的,所以不能使用中间值

  1. 线程副本cell
    LongAdder继承自Striped64类,主要逻辑方法在Striped64中。
    其中cell即为每个线程的副本变量,使用的是一个静态内部类Cell,维护了一个value变量
@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);
            }
        }
    }

问题:既然Cell这么简单,为什么不直接用long value?
我的理解:可能要设计到Java值引用问题,如果直接使用long value,在线程B进行数组扩容后,线程A修改的value值将无法反映到线程B;而使用Cell对象对value进行包装后,由于线程A只会修改Cell对象的value值,不会修改Cell对象,所以线程B的Cell中的value也会跟着改变,就不会出现值问题。更具体的了解,可能需要了解一下java的值传递(java没有引用传递)

2.Striped64主体代码
主方法为longAccumulate方法,主要处理数组的扩容和冲突检查

abstract class Striped64 extends Number {  
    @sun.misc.Contended static final class Cell { ... }  

    /** Number of CPUS, to place bound on table size */  
    static final int NCPU = Runtime.getRuntime().availableProcessors();  

    // cell数组,长度一样要是2^n,可以类比为jdk1.7的ConcurrentHashMap中的segments数组  
    transient volatile Cell[] cells;  

    // 累积器的基本值,在两种情况下会使用:  
    // 1、没有遇到并发的情况,直接使用base,速度更快;  
    // 2、多线程并发初始化table数组时,必须要保证table数组只被初始化一次,因此只有一个线程能够竞争成功,这种情况下竞争失败的线程会尝试在base上进行一次累积操作  
    transient volatile long base;  

    // 自旋标识,在对cells进行初始化,或者后续扩容时,需要通过CAS操作把此标识设置为1(busy,忙标识,相当于加锁),取消busy时可以直接使用cellsBusy = 0,相当于释放锁  
    transient volatile int cellsBusy;  

    Striped64() {  
    }  

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

    // 使用CAS将cells自旋标识更新为1  
    // 更新为0时可以不用CAS,直接使用cellsBusy就行  
    final boolean casCellsBusy() {  
        return UNSAFE.compareAndSwapInt(this, CELLSBUSY, 0, 1);  
    }  

    // 下面这两个方法是ThreadLocalRandom中的方法,不过因为包访问关系,这里又重新写一遍  

    // probe翻译过来是探测/探测器/探针这些,不好理解,它是ThreadLocalRandom里面的一个属性,  
    // 不过并不影响对Striped64的理解,这里可以把它理解为线程本身的hash值  
    static final int getProbe() {  
        return UNSAFE.getInt(Thread.currentThread(), PROBE);  
    }  

    // 相当于rehash,重新算一遍线程的hash值  
    static final int advanceProbe(int probe) {  
        probe ^= probe << 13;   // xorshift  
        probe ^= probe >>> 17;  
        probe ^= probe << 5;  
        UNSAFE.putInt(Thread.currentThread(), PROBE, probe);  
        return probe;  
    }  

    /** 
     * 核心方法的实现,此方法建议在外部进行一次CAS操作(cell != null时尝试CAS更新base值,cells != null时,CAS更新hash值取模后对应的cell.value) 
     * @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). 
     *     外部提供的二元算术操作,实例持有并且只能有一个,生命周期内保持不变,null代表LongAdder这种特殊但是最常用的情况,可以减少一次方法调用 
     * @param wasUncontended false if CAS failed before call 如果为false,表明调用者预先调用的一次CAS操作都失败了 
     */  
    final void longAccumulate(long x, LongBinaryOperator fn, boolean wasUncontended) {  
        int h;  
        // 这个if相当于给线程生成一个非0的hash值  
        if ((h = getProbe()) == 0) {  
            ThreadLocalRandom.current(); // force initialization  
            h = getProbe();  
            wasUncontended = true;  
        }  
        boolean collide = false; // True if last slot nonempty 如果hash取模映射得到的Cell单元不是null,则为true,此值也可以看作是扩容意向,感觉这个更好理解  
        for (;;) {  
            Cell[] as; Cell a; int n; long v;  
            if ((as = cells) != null && (n = as.length) > 0) { // cells已经被初始化了  
                if ((a = as[(n - 1) & h]) == null) { // hash取模映射得到的Cell单元还为null(为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; // 对没有使用的Cell单元进行累积操作(第一次赋值相当于是累积上一个操作数,求和时再和base执行一次运算就得到实际的结果)  
                                    created = true;  
                                }  
                            } finally {  
                                cellsBusy = 0; 清空自旋标识,释放锁  
                            }  
                            if (created) // 如果原本为null的Cell单元是由自己进行第一次累积操作,那么任务已经完成了,所以可以退出循环  
                                break;  
                            continue;           // Slot is now non-empty 不是自己进行第一次累积操作,重头再来  
                        }  
                    }  
                    collide = false; // 执行这一句是因为cells被加锁了,不能往下继续执行第一次的赋值操作(第一次累积),所以还不能考虑扩容  
                }  
                else if (!wasUncontended) // CAS already known to fail 前面一次CAS更新a.value(进行一次累积)的尝试已经失败了,说明已经发生了线程竞争  
                    wasUncontended = true; // Continue after rehash 情况失败标识,后面去重新算一遍线程的hash值  
                else if (a.cas(v = a.value, ((fn == null) ? v + x : fn.applyAsLong(v, x)))) // 尝试CAS更新a.value(进行一次累积) ------ 标记为分支A  
                    break; // 成功了就完成了累积任务,退出循环  
                else if (n >= NCPU || cells != as) // cell数组已经是最大的了,或者中途发生了扩容操作。因为NCPU不一定是2^n,所以这里用 >=  
                    collide = false; // At max size or stale 长度n是递增的,执行到了这个分支,说明n >= NCPU会永远为true,下面两个else if就永远不会被执行了,也就永远不会再进行扩容  
                                     // CPU能够并行的CAS操作的最大数量是它的核心数(CAS在x86中对应的指令是cmpxchg,多核需要通过锁缓存来保证整体原子性),当n >= NCPU时,再出现几个线程映射到同一个Cell导致CAS竞争的情况,那就真不关扩容的事了,完全是hash值的锅了  
                else if (!collide) // 映射到的Cell单元不是null,并且尝试对它进行累积时,CAS竞争失败了,这时候把扩容意向设置为true  
                                   // 下一次循环如果还是跟这一次一样,说明竞争很严重,那么就真正扩容  
                    collide = true; // 把扩容意向设置为true,只有这里才会给collide赋值为true,也只有执行了这一句,才可能执行后面一个else if进行扩容  
                else if (cellsBusy == 0 && casCellsBusy()) { // 最后再考虑扩容,能到这一步说明竞争很激烈,尝试加锁进行扩容 ------ 标记为分支B  
                    try {  
                        if (cells == as) {      // Expand table unless stale 检查下是否被别的线程扩容了(CAS更新锁标识,处理不了ABA问题,这里再检查一遍)  
                            Cell[] rs = new Cell[n << 1]; // 执行2倍扩容  
                            for (int i = 0; i < n; ++i)  
                                rs[i] = as[i];  
                            cells = rs;  
                        }  
                    } finally {  
                        cellsBusy = 0; // 释放锁  
                    }  
                    collide = false; // 扩容意向为false  
                    continue; // Retry with expanded table 扩容后重头再来  
                }  
                h = advanceProbe(h); // 重新给线程生成一个hash值,降低hash冲突,减少映射到同一个Cell导致CAS竞争的情况  
            }  
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) { // cells没有被加锁,并且它没有被初始化,那么就尝试对它进行加锁,加锁成功进入这个else if  
                boolean init = false;  
                try {                           // Initialize table  
                    if (cells == as) { // CAS避免不了ABA问题,这里再检测一次,如果还是null,或者空数组,那么就执行初始化  
                        Cell[] rs = new Cell[2]; // 初始化时只创建两个单元  
                        rs[h & 1] = new Cell(x); // 对其中一个单元进行累积操作,另一个不管,继续为null  
                        cells = rs;  
                        init = true;  
                    }  
                } finally {  
                    cellsBusy = 0; // 清空自旋标识,释放锁  
                }  
                if (init) // 如果某个原本为null的Cell单元是由自己进行第一次累积操作,那么任务已经完成了,所以可以退出循环  
                    break;  
            }  
            else if (casBase(v = base, ((fn == null) ? v + x : fn.applyAsLong(v, x)))) // cells正在进行初始化时,尝试直接在base上进行累加操作  
                break;                          // Fall back on using base 直接在base上进行累积操作成功了,任务完成,可以退出循环了  
        }  
    }  

    // double的不讲,更long的逻辑基本上是一样的  
    final void doubleAccumulate(double x, DoubleBinaryOperator fn, boolean wasUncontended);  

    // Unsafe mechanics Unsafe初始化  
    private static final sun.misc.Unsafe UNSAFE;  
    private static final long BASE;  
    private static final long CELLSBUSY;  
    private static final long PROBE;  
    static {  
        try {  
            UNSAFE = sun.misc.Unsafe.getUnsafe();  
            Class<?> sk = Striped64.class;  
            BASE = UNSAFE.objectFieldOffset  
                (sk.getDeclaredField("base"));  
            CELLSBUSY = UNSAFE.objectFieldOffset  
                (sk.getDeclaredField("cellsBusy"));  
            Class<?> tk = Thread.class;  
            PROBE = UNSAFE.objectFieldOffset  
                (tk.getDeclaredField("threadLocalRandomProbe"));  
        } catch (Exception e) {  
            throw new Error(e);  
        }  
    }  

} 

3.LongAdder的add()方法
add(long x) 方法不仅仅实现加,参数为负就为减;调用longAccumulate来进行操作

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

jdk1.8的ConcurrentHashMap中,没有再使用Segment,使用了一个简单的仿造LongAdder实现的计数器,这样能够保证计数效率不低于使用Segment的效率。

jdk1.8 LongAdder源码学习

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页