原子自增_CAS底层原理(原子类)

目录:

• CAS 与 volatile

• 原子整数

• 原子引用

  • ABA问题

• 原子累加器

  • 伪共享

• Unsafe

概念

CAS的全称是Compare-And-Swap，它是CPU并发原语

它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的

CAS并发原语体现在Java语言中就是sun.misc.Unsafe类的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令，这是一种完全依赖于硬件的功能，通过它实现了原子操作，再次强调，由于CAS是一种系统原语，原语属于操作系统用于范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致的问题，也就是说CAS是线程安全的。

转账案例案例

使用CAS解决

class AccountCas implements Account {    private AtomicInteger balance;  //使用原子整形AtomicInteger     public AccountCas(int balance) {        this.balance = new AtomicInteger(balance);    }    @Override    public Integer getBalance() {        return balance.get();        }    @Override    public void withdraw(Integer amount) {        while(true) {            // 获取余额的最新值            int prev = balance.get();            // 要修改的余额            int next = prev - amount;            // 真正修改            if(balance.compareAndSet(prev, next)) {                break;    //如果最新的余额与之前的余额不一致继续下一轮循环，一致则退出循环              }        }    }}

一. CAS 与 volatile

前面看到的 AtomicInteger 的解决方法，内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢？

public void withdraw(Integer amount) {  while(true) {    // 获取余额的最新值    int prev = balance.get();    // 要修改的余额    int next = prev - amount;    /* compareAndSet 正是做这个检查，在 set 前，先比较 prev 与当前值       - 不一致了，next 作废，返回 false 表示失败       比如，别的线程已经做了减法，当前值已经被减成了 990       那么本线程的这次 990 就作废了，进入 while 下次循环重试       - 一致，以 next 设置为新值，返回 true 表示成功*/    // 真正修改    if(balance.compareAndSet(prev, next)) {      break;    //如果最新的余额与之前的余额不一致继续下一轮循环，一致则退出循环      }  }}

其中的关键是 compareAndSet，它的简称就是 CAS (也有 Compare And Swap 的说法)，它必须是原子操作

volatile
    获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。

    它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取 它的值，线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改，对另一个线程可见。

注意

    volatile 仅仅保证了共享变量的可见性，让其它线程能够看到最新值，但不能解决指令交错问题(不能保证原 子性)

    CAS 必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果

为什么无锁效率高

• 无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized 会让线程在没有获得锁的时 候，发生上下文切换，进入阻塞。打个比喻

• 线程就好像高速跑道上的赛车，高速运行时，速度超快，一旦发生上下文切换，就好比赛车要减速、熄火， 等被唤醒又得重新打火、启动、加速... 恢复到高速运行，代价比较大

• 但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑 道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还 是会导致上下文切换。

CAS 的特点

• 结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下。

• CAS 是基于乐观锁的思想:最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再 重试呗。

• synchronized 是基于悲观锁的思想:最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想 改，我改完了解开锁，你们才有机会。

• CAS 体现的是无锁并发、无阻塞并发，请仔细体会这两句话的意思

  • 因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一

  • 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

二. 原子整数

J.U.C 并发包提供了:

• AtomicBoolean

• AtomicInteger

• AtomicLong

以 AtomicInteger 为例

AtomicInteger i = new AtomicInteger(0);// 获取并自增(i = 0, 结果 i = 1, 返回 0)，类似于 i++System.out.println(i.getAndIncrement());// 自增并获取(i = 1, 结果 i = 2, 返回 2)，类似于 ++iSystem.out.println(i.incrementAndGet());// 自减并获取(i = 2, 结果 i = 1, 返回 1)，类似于 --iSystem.out.println(i.decrementAndGet());// 获取并自减(i = 1, 结果 i = 0, 返回 1)，类似于 i--System.out.println(i.getAndDecrement());// 获取并加值(i = 0, 结果 i = 5, 返回 0)System.out.println(i.getAndAdd(5));// 加值并获取(i = 5, 结果 i = 0, 返回 0)System.out.println(i.addAndGet(-5));// 获取并更新(i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0)// 其中函数中的操作能保证原子，但函数需要无副作用System.out.println(i.getAndUpdate(p -> p - 2));// 更新并获取(i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0)// 其中函数中的操作能保证原子，但函数需要无副作用System.out.println(i.updateAndGet(p -> p + 2));// 获取并计算(i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0)// 其中函数中的操作能保证原子，但函数需要无副作用// getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的// getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 finalSystem.out.println(i.getAndAccumulate(10, (p, x) -> p + x));// 计算并获取(i = 10, p 为 i 的当前值, x 为参数1, 结果 i = 0, 返回 0)// 其中函数中的操作能保证原子，但函数需要无副作用System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));

updateAndGet原理：

   // 传入一个lambda表达式, 这个表达式执行完会返回一个值, 作为目标值   public static int updateAndGet(AtomicInteger i, IntUnaryOperator operator) {        while (true) {            int prev = i.get();            int next = operator.applyAsInt(prev);            if (i.compareAndSet(prev, next)) {                return next;            }        }    }

三. 原子引用

为什么需要原子引用类型?

• AtomicReference 原子引用

• AtomicMarkableReference  带标记(true/flas)

• AtomicStampedReference  带版本(整数)

class DecimalAccountCas implements DecimalAccount {    // private balance;    private AtomicReference balance;    public DecimalAccountCas(BigDecimal balance) {//        this.balance = balance;        this.balance = new AtomicReference<>(balance);    }    @Override    public BigDecimal getBalance() {        return balance.get();    }    @Override    public void withdraw(BigDecimal amount) {        while(true) {            BigDecimal prev = balance.get();            BigDecimal next = prev.subtract(amount);            if (balance.compareAndSet(prev, next)) {                break;            }        }    }}

ABA 问题及解决

ABA 问题

static AtomicReference ref = new AtomicReference<>("A");public static void main(String[] args) throws InterruptedException {   log.debug("main start...");   // 获取值 A   // 这个共享变量被它线程修改过？   String prev = ref.get();   other();   //   sleep(1);    // 尝试改为 C   log.debug("change A->C {}", ref.compareAndSet(prev, "C"));  }private static void other() {   new Thread(() -> {     log.debug("change A->B {}", ref.compareAndSet(ref.get(), "B"));   }, "t1").start();   sleep(0.5)   new Thread(() -> {     log.debug("change B->A {}", ref.compareAndSet(ref.get(), "A"));   }, "t2").start();}

输出

11:29:52.325 c.Test36 [main] - main start... 11:29:52.379 c.Test36 [t1] - change A->B true 11:29:52.879 c.Test36 [t2] - change B->A true 11:29:53.880 c.Test36 [main] - change A->C true

 主线程仅能判断出共享变量的值与最初值 A 是否相同，不能感知到这种从 A 改为 B 又 改回 A 的情况，如果主线程希望：只要有其它线程【动过了】共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再加一个版本号。

AtomicStampedReference

static AtomicStampedReference ref = new AtomicStampedReference<>("A", 0);public static void main(String[] args) throws InterruptedException {   log.debug("main start...");   // 获取值 A   String prev = ref.getReference();  //之前是ref.get(),这里是getReference()   // 获取版本号   int stamp = ref.getStamp();   log.debug("版本 {}", stamp);   // 如果中间有其它线程干扰，发生了 ABA 现象   other();   sleep(1);   // 尝试改为 C   log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));  }private static void other() {   new Thread(() -> {     log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B",      ref.getStamp(), ref.getStamp() + 1));     log.debug("更新版本为 {}", ref.getStamp());   }, "t1").start();   sleep(0.5);   new Thread(() -> {     log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A",      ref.getStamp(), ref.getStamp() + 1));     log.debug("更新版本为 {}", ref.getStamp());   }, "t2").start();}

输出

c.Test36 [main] - main start... 15:41:34.894 c.Test36 [main] - 版本 0 15:41:34.956 c.Test36 [t1] - change A->B true 15:41:34.956 c.Test36 [t1] - 更新版本为 1 15:41:35.457 c.Test36 [t2] - change B->A true 15:41:35.457 c.Test36 [t2] - 更新版本为 2 15:41:36.457 c.Test36 [main] - change A->C false

    AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，如：A -> B -> A -> C ，通过AtomicStampedReference，我们可以知道，引用变量中途被更改了几次。    但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过，所以就有了：

AtomicMarkableReference

代码演示:

class GarbageBag {   String desc;   public GarbageBag(String desc) {   this.desc = desc;   }   public void setDesc(String desc) {     this.desc = desc;    }   @Override   public String toString() {     return super.toString() + " " + desc;   }}@Slf4jpublic class TestABAAtomicMarkableReference {   public static void main(String[] args) throws InterruptedException {   GarbageBag bag = new GarbageBag("装满了垃圾");   // 参数2 mark 可以看作一个标记，表示垃圾袋满了   AtomicMarkableReference ref = new AtomicMarkableReference<>(bag, true);   log.debug("主线程 start...");   GarbageBag prev = ref.getReference();   log.debug(prev.toString());   new Thread(() -> {     log.debug("打扫卫生的线程 start...");     bag.setDesc("空垃圾袋");     while (!ref.compareAndSet(bag, bag, true, false)) {}     log.debug(bag.toString());   }).start();   Thread.sleep(1000);   log.debug("主线程想换一只新垃圾袋？");   boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);   log.debug("换了么？" + success);   log.debug(ref.getReference().toString());   }}

输出

2019-10-13 15:30:09.264 [main] 主线程 start... 2019-10-13 15:30:09.270 [main] cn.itcast.GarbageBag@5f0fd5a0 装满了垃圾2019-10-13 15:30:09.293 [Thread-1] 打扫卫生的线程 start... 2019-10-13 15:30:09.294 [Thread-1] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋2019-10-13 15:30:10.294 [main] 主线程想换一只新垃圾袋？2019-10-13 15:30:10.294 [main] 换了么？false 2019-10-13 15:30:10.294 [main] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋

四. 原子数组

• AtomicIntegerArray

• AtomicLongArray

• AtomicReferenceArray

/** 参数1，提供数组、可以是线程不安全数组或线程安全数组 参数2，获取数组长度的方法 参数3，自增方法，回传 array, index 参数4，打印数组的方法*/// supplier 提供者 无中生有 ()->结果// function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果// consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->private static  void demo(   Supplier arraySupplier,   Function lengthFun,   BiConsumer putConsumer,   Consumer printConsumer ) {   List ts = new ArrayList<>();   T array = arraySupplier.get();   int length = lengthFun.apply(array);   for (int i = 0; i < length; i++) {     // 每个线程对数组作 10000 次操作     ts.add(new Thread(() -> {       for (int j = 0; j < 10000; j++) {         putConsumer.accept(array, j%length);       }     }));   }   ts.forEach(t -> t.start()); // 启动所有线程   ts.forEach(t -> {     try {       t.join();     } catch (InterruptedException e) {       e.printStackTrace();     } }); // 等所有线程结束 printConsumer.accept(array);}

不安全的数组

demo(   ()->new int[10],   (array)->array.length,   (array, index) -> array[index]++,   array-> System.out.println(Arrays.toString(array)));

输出

[9870, 9862, 9774, 9697, 9683, 9678, 9679, 9668, 9680, 9698]

安全的数组

demo(   ()-> new AtomicIntegerArray(10),   (array) -> array.length(),   (array, index) -> array.getAndIncrement(index),   array -> System.out.println(array));

输出

[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

五.字段更新器

• AtomicReferenceFieldUpdater // 域 字段

• AtomicIntegerFieldUpdater

• AtomicLongFieldUpdater

利用字段更新器，可以针对对象的某个域(Field)进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现异常。

Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type

public class Test5 {   private volatile int field;   public static void main(String[] args) {     AtomicIntegerFieldUpdater fieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Test5.class, "field");     Test5 test5 = new Test5();     fieldUpdater.compareAndSet(test5, 0, 10);     // 修改成功 field = 10     System.out.println(test5.field);     // 修改成功 field = 20     fieldUpdater.compareAndSet(test5, 10, 20);     System.out.println(test5.field);     // 修改失败 field = 20     fieldUpdater.compareAndSet(test5, 10, 30);     System.out.println(test5.field);   }}

六.原子累加器

累加器性能比较

private static void demo(Supplier adderSupplier, Consumer action) {   T adder = adderSupplier.get();   long start = System.nanoTime();   List 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());}

输出

1000000 cost:43 1000000 cost:9 1000000 cost:7 1000000 cost:7 1000000 cost:7 1000000 cost:31 1000000 cost:27 1000000 cost:28 1000000 cost:24 1000000 cost:22

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

源码之 LongAdder

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

LongAdder 类有几个关键域

// 累加单元数组, 懒惰初始化transient volatile Cell[] cells;// 基础值, 如果没有竞争, 则用 cas 累加这个域 transient volatile long base;// 在 cells 创建或扩容时, 置为 1, 表示加锁 transient volatile int cellsBusy;// 不要用于实践!!! 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);  } }

测试

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);   }  // 省略不重要代码 }

得从缓存说起
缓存与内存的速度比较

从cpu到	大约需要的时钟周期
寄存器	1 cycle(4GHz的cpu大约 0.25ns)
L1	3 ~ 4 cycle
L2	10 ~ 20 cycle
L3	40 ~ 45 cycle
内存	120 ~ 240 cycle

因为 CPU 与 内存的速度差异很大，需要靠预读数据至缓存来提升效率。
而缓存以缓存行为单位，每个缓存行对应着一块内存，一般是 64 byte(8 个 long) 

缓存的加入会造成数据副本的产生，即同一份数据会缓存在不同核心的缓存行中
CPU 要保证数据的一致性，如果某个 CPU 核心更改了数据，其它 CPU 核心对应的整个缓存行必须失效

因为 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 用来解决这个问题，它的原理是在使用此注解的对象或字段的前后各增加 128 字节大小的padding，从而让 CPU 将对象预读至缓存时占用不同的缓存行，这样，不会造成对方缓存行的失效

public void add(long x) {   // as 为累加单元数组   // b 为基础值  // x 为累加值  Cell[] as; long b, v; int m; Cell a;   // 进入 if 的两个条件  // 1. as 有值, 表示已经发生过竞争, 进入 if  // 2. cas 给 base 累加时失败了, 表示 base 发生了竞争, 进入 if   if ((as = cells) != null || !casBase(b = base, b + x)) {    // uncontended 表示 cell 没有竞争 boolean uncontended = true;    if (      // as 还没有创建      as == null || (m = as.length - 1) < 0 ||      // 当前线程对应的 cell 还没有      (a = as[getProbe() & m]) == null ||      // cas 给当前线程的 cell 累加失败 uncontended=false ( a 为当前线程的 cell )       !(uncontended = a.cas(v = a.value, v + x))    ){      longAccumulate(x, null, uncontended);     }  }}

add 流程图

final void longAccumulate(long x, LongBinaryOperator fn,                           boolean wasUncontended) {  int h;  // 当前线程还没有对应的 cell, 需要随机生成一个 h 值用来将当前线程绑定到 cell   if ((h = getProbe()) == 0) {    // 初始化 probe     ThreadLocalRandom.current();    // h 对应新的 probe 值, 用来对应 cell     h = getProbe();    wasUncontended = true;  }  // collide 为 true 表示需要扩容   boolean collide = false;  for (;;) {    Cell[] as; Cell a; int n; long v;    // 已经有了 cells    if ((as = cells) != null && (n = as.length) > 0) {      // 还没有 cell      if ((a = as[(n - 1) & h]) == null) {        // 为 cellsBusy 加锁, 创建 cell, cell 的初始累加值为 x         // 成功则 break, 否则继续 continue 循环      }      // 有竞争, 改变线程对应的 cell 来重试 cas       else if (!wasUncontended)        wasUncontended = true;      // cas 尝试累加, fn 配合 LongAccumulator 不为 null, 配合 LongAdder 为 null      else if (a.cas(v = a.value, ((fn == null) ? v + x : fn.applyAsLong(v, x))))        break;      // 如果 cells 长度已经超过了最大长度, 或者已经扩容, 改变线程对应的 cell 来重试 cas       else if (n >= NCPU || cells != as)        collide = false;      // 确保 collide 为 false 进入此分支, 就不会进入下面的 else if 进行扩容了       else if (!collide)        collide = true; // 加锁      else if (cellsBusy == 0 && casCellsBusy()) {         // 加锁成功, 扩容        continue;       }      // 改变线程对应的 cell      h = advanceProbe(h);     }    // 还没有 cells, 尝试给 cellsBusy 加锁    else if (cellsBusy == 0 && cells == as && casCellsBusy()) {      // 加锁成功, 初始化 cells, 最开始长度为 2, 并填充一个 cell      // 成功则 break;     }    // 上两种情况失败, 尝试给 base 累加    else if (casBase(v = base, ((fn == null) ? v + x : fn.applyAsLong(v, x))))      break;     }}

longAccumulate 流程图

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

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

七.Unsafe

概述
Unsafe 对象提供了非常底层的，操作内存、线程的方法，Unsafe 对象不能直接调用，只能通过反射获得

public class UnsafeAccessor {   static Unsafe unsafe;  static {     try {      Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe"); theUnsafe.setAccessible(true);      unsafe = (Unsafe) theUnsafe.get(null);    } catch (NoSuchFieldException | IllegalAccessException e) {       throw new Error(e);    }   }  static Unsafe getUnsafe() {     return unsafe;  } }

Unsafe CAS 操作

@Dataclass Student {  volatile int id;   volatile String name;}

Unsafe unsafe = UnsafeAccessor.getUnsafe();Field id = Student.class.getDeclaredField("id");Field name = Student.class.getDeclaredField("name");// 获得成员变量的偏移量long idOffset = UnsafeAccessor.unsafe.objectFieldOffset(id); long nameOffset = UnsafeAccessor.unsafe.objectFieldOffset(name);Student student = new Student();// 使用 cas 方法替换成员变量的值UnsafeAccessor.unsafe.compareAndSwapInt(student, idOffset, 0, 20); // 返回 true UnsafeAccessor.unsafe.compareAndSwapObject(student, nameOffset, null, "张三"); // 返回 trueSystem.out.println(student);

输出

Student(id=20, name=张三)