剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)

  • 作者简介:大家好,我是爱吃芝士的土豆倪,24届校招生Java选手,很高兴认识大家
  • 系列专栏:Spring源码、JUC源码
  • 如果感觉博主的文章还不错的话,请三连支持一下博主哦
  • 博主正在努力完成2023计划中:源码溯源,一探究竟
  • 联系方式:nhs19990716,加我进群,大家一起学习,一起进步,一起对抗互联网寒冬

文章目录

    • 累加器性能比较
    • 源码之 LongAdder
      • 原理之伪共享
      • LongAdder源码

累加器性能比较

private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
        T adder = adderSupplier.get();
        long start = System.nanoTime();
        List<Thread> ts = new ArrayList<>();
        // 4 个线程,每人累加 50 万
        for (int i = 0; i < 40; i++) {
            ts.add(new Thread(() -> {
                for (int j = 0; j < 500000; j++) {
                    action.accept(adder);
                }
            }));
        }
        ts.forEach(t -> t.start());
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(adder + " cost:" + (end - start)/1000_000);
    }

比较 AtomicLong 与 LongAdder

for (int i = 0; i < 5; i++) {
 	demo(() -> new LongAdder(), adder -> adder.increment());
}
for (int i = 0; i < 5; i++) {
 	demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());
}

输出

20000000 cost:68
20000000 cost:8
20000000 cost:7
20000000 cost:7
20000000 cost:22

20000000 cost:352
20000000 cost:240
20000000 cost:327
20000000 cost:338
20000000 cost:321

第一次运行看不出来,jvm加入虚拟机内部,程序被反复执行后,才会做出优化,执行一次,效果看不出来。

性能提升的原因很简单,就是在有竞争时,设置多个累加单元,Therad-0 累加 Cell[0],而 Thread-1 累加
Cell[1]… 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量,因此减少了 CAS 重试失败,从而提高性
能。换句话说,核心数越多,提升性能越明显

源码之 LongAdder

LongAdder 是并发大师 @author Doug Lea (大哥李)的作品,设计的非常精巧

LongAdder 类有几个关键域

// 累加单元数组, 懒惰初始化(多线程去累加的时候,每个线程用各自的一个Cell累加单元来累加,可以减少从试,从而提高性能)
transient volatile Cell[] cells;

// 基础值, 如果没有竞争, 则用 cas 累加这个域
transient volatile long base;

// 在 cells 创建或扩容时, 置为 1, 表示加锁
transient volatile int cellsBusy;

cas 锁

public class LockCas {
    private AtomicInteger state = new AtomicInteger(0);
    public void lock() {
        while (true) {
            if (state.compareAndSet(0, 1)) {
                break;
            }
        }
    }
    public void unlock() {
        log.debug("unlock...");
        state.set(0);
    }
}

0 没加锁
1 加锁

第一个线程,相当于将0 变成 1。此时第二个线程,再将0 变成 1,那就加锁失败了。会一直while(true)

测试

LockCas lock = new LockCas();
new Thread(() -> {
 log.debug("begin...");
 lock.lock();
 try {
 log.debug("lock...");
 sleep(1);
 } finally {
 lock.unlock();
 }
}).start();
new Thread(() -> {
 log.debug("begin...");
 lock.lock();
 try {
 log.debug("lock...");
 } finally {
 lock.unlock();
 }
}).start();

输出

18:27:07.198 c.Test42 [Thread-0] - begin... 
18:27:07.202 c.Test42 [Thread-0] - lock... 
18:27:07.198 c.Test42 [Thread-1] - begin... 
18:27:08.204 c.Test42 [Thread-0] - unlock... 
18:27:08.204 c.Test42 [Thread-1] - lock... 
18:27:08.204 c.Test42 [Thread-1] - unlock... 

原理之伪共享

其中 Cell 即为累加单元

// 防止缓存行伪共享
@sun.misc.Contended
static final class Cell {
    volatile long value;
    Cell(long x) { value = x; }

    // 最重要的方法, 用来 cas 方式进行累加, prev 表示旧值, next 表示新值
    final boolean cas(long prev, long next) {
        return UNSAFE.compareAndSwapLong(this, valueOffset, prev, next);
    }
    // 省略不重要代码
}

得从缓存说起

缓存与内存的速度比较

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第1张图片

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第2张图片

因为 CPU 与 内存的速度差异很大,需要靠预读数据至缓存来提升效率。

缓存以缓存行为单位每个缓存行对应着一块内存,一般是 64 byte(8 个 long) 重点!!!

缓存的加入会造成数据副本的产生,即同一份数据会缓存在不同核心的缓存行中

CPU 要保证数据的一致性,如果某个 CPU 核心更改了数据,其它 CPU 核心对应的整个缓存行必须失效

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第3张图片

因为 Cell 是数组形式,在内存中是连续存储的,一个 Cell 为 24 字节(16 字节的对象头和 8 字节的 value),因
此缓存行可以存下 2 个的 Cell 对象。这样问题来了:

  • Core-0 要修改 Cell[0]
  • Core-1 要修改 Cell[1]

无论谁修改成功,都会导致对方 Core 的缓存行失效,比如 Core-0 中 Cell[0]=6000, Cell[1]=8000 要累加
Cell[0]=6001, Cell[1]=8000 ,这时会让 Core-1 的缓存行失效

@sun.misc.Contended (实际上就是防止 一个缓存行容纳 多个 Cell对象)用来解决这个问题,它的原理是在使用此注解的对象或字段的前后各增加 128 字节大小的padding,从而让 CPU 将对象预读至缓存时占用不同的缓存行,这样,不会造成对方缓存行的失效。

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第4张图片

LongAdder源码

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第5张图片

累加主要调用下面的方法

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

从if开始分析,cells是累加单元的数组,判断为空还是不为空,cells数组是懒惰创建的,没有竞争的时候是null,竞争发生的时候才会去创建cells数组。从而再创建里面的cell累加单元,一开始先判断是否有竞争,如果没竞争,那么一开始是为空的。后半部分是对基础累加值进行累加,这里显然是cas操作,使用casBase对基础的域进行累加。如果成功了就不会进入到if块,如果基础累加值失败了,那么就进入到 里面的if块。

此时cells还是为空,那么就直接进入了longAccumulate 方法中。这里面主要会涉及到cells、cell的创建。

如果cells不为空,代表着以前发生过竞争了,需要去判断当前的线程有没有一个对应的Cell被创建了,如果是null就代表没有没有被创建,代表 (a = as[getProbe() & m]) == null 这个条件直接成立,直接就会进入 longAccumulate 方法

如果当前条件不成立,当前线程有一个累加单元了,其中a就是累加单元,那么就执行累加单元的cas,成功了,就不会进入 longAccumulate 方法了

add 流程图

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第6张图片

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 (;;) { // 相当于while(true)
            Cell[] as; Cell a; int n; long v;
            if ((as = cells) != null && (n = as.length) > 0) { ... } // celss数组不为空的情况
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) { // cells为空的情况
            	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
        }
    }

首先先研究 cells数组为空的情况

cellsBusy首先是一个标记位,0代表未加锁,1代表加锁,因为我们要创建cells数组需要为其加锁,如果其他线程如果也想创建这个数组就会产生了冲突。

后面 cells == as 代表还没有其他线程去改变这个 cells ,也许有其他线程也在去尝试去创建cells,创建成功了,就会将其复制给cells变量,as是最初读到的数组的引用,cells有可能是别的线程创建出来的新的数组的引用,所以需要对比一下,对比的目的就是看有没有别人修改过这个引用。

casCellsBusy() 其实将cellsBusy从0变为1,使用cas操作去尝试去加锁,这个方法相当于图中加锁的逻辑。

如果加锁失败就进入到了 和它平级的else if里了,去base上使用cas进行累加,如果base累加成功了,就return,如果失败了就重回循环。

进来以后,再次判断看看其他线程是否将cells创建好了,后续创建一个大小为2的累加单元数组,然后创建累加单元,然后赋值cells。

这里面需要注意就是虽然cells大小是2,但是累加单元cell只创建了一个,还有一个是空着的,这也是懒惰初始化的关键,不到万不得已不会创建的。

最终cellsBusy设置为0,解锁。

longAccumulate 流程图

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第7张图片

for (;;) {
            Cell[] as; Cell a; int n; long v;
            if ((as = cells) != null && (n = as.length) > 0) { // cells创建好了,cell还没有创建
                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 (cellsBusy == 0 && cells == as && casCellsBusy()) {...}
            else if (casBase(v = base, ((fn == null) ? v + x :
                                        fn.applyAsLong(v, x))))
                break;                          // Fall back on using base
        }

cells创建好了,但是线程对应的cell还没有创建,因为刚才也看到了,cells创建出来,只给当前那个线程创建了累加单元,假设我是另一个线程,那么未必累加单元对象就创建好了,因此,我们要为这个线程在没有对应的累加单元的时候,将累加单元给它创建出来,累加单元是用到时才创建。

定位到 if ((a = as[(n - 1) & h]) == null) 这段代码,实际上获取当前线程看看有没有对应的a的累加单元,如果为null,那么就还没有对应的累加单元。

首先创建了一个Cell对象,但是此时还没有存储到数组里面去,数组中肯定还有空位,等着放入累加单元。

首先根据cellsBusy判断是否上锁,如果没上锁就上锁。因为这是需要改数组内容,将新创建出来的累加单元设置到数组中的空着的地方,需要对数组上锁。如果上锁失败,就回到循环入口。

如果加锁成功,又做了一遍检查,再次确保数组是不为空的,数组的长度是不为零的,然后又检查这个线程对应的那个数组中空的槽位是不是真的是null,是null的话代表着这个cell对象没有别人创建,那么前面创建的cell对象就可以存入数组的下标中去,如果不为空,说明有其他线程在数组的该下标下创建了cell对象,那前面的cell对象就白创建了,就再次回到循环中。

成功了把锁解开,然后break;

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第8张图片

if ((as = cells) != null && (n = as.length) > 0) {
                if ((a = as[(n - 1) & h]) == null) {
                    ...
                }
                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); // 改变线程对应的cell
            }

如果cells存在并且cell创建好了,此时会进入到这行代码else if (a.cas(v = a.value, ((fn == null) ? v + x :fn.applyAsLong(v, x))))

累加单元就是a,调用a的cas方法,对原来的值进行累加,如果失败了,进入下面的else if,首先会检查是否超过了cpu上限,n就是数组的长度,看看n是否会大于cpu的个数,如果已经大于等于cpu个数的话,那么这个cells数组再扩容其实就没有意义了,其实也就是防止走后面的扩容逻辑。

如果没有超过cpu上线,那就走加锁逻辑,如果上锁失败了,那么其实就 改变线程对应的累加单元。

如果没有超过cpu上线,就会执行扩容逻辑,其实本质上是使用移位运算符创建一个二倍长度的数组,然后将原数组中的cell赋值过来即可,然后最终将新cells也赋值过来。

每个线程刚进入 longAccumulate 时,会尝试对应一个 cell 对象(找到一个坑位)

剑指JUC原理-10.并发编程大师的原子累加器底层优化原理(与人类的优秀灵魂对话)_第9张图片

获取最终结果通过 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;
    }

你可能感兴趣的:(JUC,开发语言,java,juc)