基本概念

CAS（Compare And Swap）是一种比较交换算法，很多人会把CAS和自旋锁混为一谈，两者还是有差别，前者是一种原子算法，目的是在不使用操作系统互斥信号量的重量级锁的前提下提供一种原子操作，后者基于CAS算法实现。
操作系统底层对CAS的都提供了不同的指令级实现：

  • x86 cmpxchg
  • arm LL/SC

查看openJDK的源码实现的代码片段。完整代码地址：源码地址

  1. UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  2.     UnsafeWrapper("Unsafe_CompareAndSwapInt");
  3. oop p = JNIHandles::resolve(obj);
  4. jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  5. // 使用了Atomic::cmpxchg来保证原子性。
  6. return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
  7. UNSAFE_END

Java中提供了sun.misc.Unsafe类来提供CAS操作，这个类中大部分的方法为native方法，调用JVM底层的C++实现，该类中提供了一个获得操作native方法的对象：

  1. @CallerSensitive
  2. public static Unsafe getUnsafe() {
  3.     Class var0 = Reflection.getCallerClass();
  4.     if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
  5.         throw new SecurityException("Unsafe");
  6.     } else {
  7.         return theUnsafe;
  8.     }
  9. }

CAS的核心思想是比较并交换，CAS的核心包含三个值：

  • V 要被更新的变量值 主存
  • E 预期的值 线程内存（V的副本）
  • N 更新的值

当 V == E 的时候说明 V 的值与期望值相同，这个时候可以将V更新为新的值N，如果不一致就将主存的值同步到线程内存副本，继续下一次比较。查看Unsafe中getAndAddInt实现

  1. public final int getAndAddInt(Object var1, long var2, int var4) {
  2.     int var5;
  3.     do {
  4.         var5 = this.getIntVolatile(var1, var2);
  5.     } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
  7.     return var5;
  8. }

可以将这个操作抽象为：

  1. do{   
  2.   备份旧数据；  
  3.   基于旧数据构造新数据；  
  4. }while(!CAS( 内存地址，备份的旧数据，新数据 ))

当两者进行比较时，如果相等，则证明共享数据没有被修改，替换成新值，然后继续往下运行；如果不相等，说明共享数据已经被修改，放弃已经所做的操作，然后重新执行刚才的操作。容易看出 CAS 操作是基于共享数据不会被修改的假设，采用了类似于数据库的 commit-retry 的模式。当同步冲突出现的机会很少时，这种假设能带来较大的性能提升。
这中间的过程其实是分为了两部，很有可能在比较的过程中，还没有修改时被别的线程已经修改了这就容易出现并发场景的变量安全问题，这就要求了CAS是一个原子操作，这个在操作系统指令级已经实现。

注意事项

当然CAS不是说没有任何缺点的，在使用的过程中需要注意自旋锁基于CAS的实现及优化细节，另外就是需要注意ABA问题，接下来对这两种情况需要注意的点进行介绍。

自旋锁

Java中synchronized锁实现存在一个锁升级的过程，在轻量级锁膨胀为重量级锁的过程中会先尝试基于CAS的自旋操作，也就是所谓的自旋锁。轻量级锁升级为重量级锁之前，线程执行monitorenter指令进入Monitor对象的EntryList队列，此时会通过自旋尝试获得锁，自旋次数超过了一定阈值（默认10），才会升级为重量级锁，等待线程被唤起。
自旋的这个过程是短暂的，但是如果过多的线程进入自旋状态，大量的线程进程进入自旋状态会占用CPU的时间片，导致CPU利用率飙升，因此有大量线程等待切换执行的场景更适合用synchronized。此外JVM也对自旋场景进行了优化：

  • 如果平均负载小于CPUs则一直自旋
  • 如果有超过(CPUs/2)个线程正在自旋，则后来线程直接阻塞
  • 如果正在自旋的线程发现Owner发生了变化则延迟自旋时间（自旋计数）或进入阻塞
  • 如果CPU处于节电模式则停止自旋
  • 自旋时间的最坏情况是CPU的存储延迟（CPU A存储了一个数据，到CPU B得知这个数据直接的时间差）
  • 自旋时会适当放弃线程优先级之间的差异

    说明：CAS是一次原子操作，自旋锁是为了避免线程在轻量级锁转化为重量解锁，消耗系统互斥信号量占用资源，采取的一种优化手段，但是自旋会占用CPU，并不能代替阻塞，默认自旋次数为10次，可以通过JVM参数配置-XX:PreBlockSpin次数。 此外，高效并发是JDK1.5到JDK1.6的一个重要改进，出现了适应性自旋（Adaptive Spinning）、锁消除（Lock Elimination）、锁粗化（Lock Coarsening）、轻量级锁（Lightweight Locking）和偏向锁（Biased Locking）等一系列锁优化技术。

ABA问题

CAS中另一个经典问题就是ABA问题。ABA指的是两个线程操作同一个变量，两个线程开始拿到主存变量副本都为A，Thread-1做写操作前，Thread-2将原值改为B，但是又做了某些操作改回A，Thread-1通过CAS操作也成功了，虽然这个过程A-B-A，在Thread-1操作时变量值没有发生改变，不影响业务逻辑，结果没有问题，但是不代表这个过程就是没有问题的。如果链表的头在变化了两次后恢复了原值，不代表链表就没有变化。
如果添加了版本标记是不是就可以解决这种问题，具体思路就是由原来的A-B-A转换为1A-2B-3A，是不是就解决了这种问题，JUC中atomic包提供了一个工具类AtomicStampedReference就实现了这种操作。

An AtomicStampedReference maintains an object reference along with an integer “stamp”, that can be updated atomically. AtomicStampedReference 维护一个对象引用以及一个可以自动更新的整数“标记”。

查看类中相关属性和字段
AtomicStampedReference.png
属性只有两个一个对象引用reference和一个自动更新标记值stamp。
其内部包含一个静态内部类Pair将reference和stamp进行了绑定，构造方法需要传递初始版本号。

  1. private static class Pair<T> {
  2.     final T reference;
  3.     final int stamp;
  4.     private Pair(T reference, int stamp) {
  5.         this.reference = reference;
  6.         this.stamp = stamp;
  7.     }
  8.     static <T> Pair<T> of(T reference, int stamp) {
  9.         return new Pair<T>(reference, stamp);
  10.     }
  11. }

查看原子操作compareAndSet方法

  1. 比较期望引用、当前引用、新引用和期望stamp、当前stamp、新stamp之间的关系，如果都为true返回true
  2. 如果1比较结果为false，通过CAS操作构造一个新的Pair对象并更新pair，返回CAS的操作结果 ```java public boolean compareAndSet(V expectedReference,
    1.                       V   newReference,
    2.                       int expectedStamp,
    3.                       int newStamp) {
    // 获取当前pair（元素值，版本号） Pair current = pair; return
    1.  // 引用没变
    2.  expectedReference == current.reference &&
    3.  // 版本号没变
    4.  expectedStamp == current.stamp &&
    5.  // 新引用等于旧引用
    6.  ((newReference == current.reference &&
    7.  // 新版本号等于旧版本号
    8.    newStamp == current.stamp) ||
    9.    // 构造新的Pair对象并CAS更新
    10.   casPair(current, Pair.of(newReference, newStamp)));
    }

private boolean casPair(Pair cmp, Pair val) { // 调用Unsafe的compareAndSwapObject()方法CAS更新pair的引用为新引用 return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val); }

  1. 其实除了版本号之外，这里也提供了一个解决ABA的思路，不重复使用节点的引用，每次使用新的节点引用来进行比较。<br />ABA解决方案：
  3. - 引入版本号
  4. - 不重复使用节点引用
  6. 通过一个简单的例子演示AtomicStampedReference使用
  7. ```java
  8. package stampreference;
  10. import java.util.concurrent.TimeUnit;
  11. import java.util.concurrent.atomic.AtomicStampedReference;
  13. /**
  14.  * 邮票参考测试
  15.  *
  16.  * @author starsray
  17.  * @date 2021/12/21
  18.  */
  19. public class StampReferenceTest {
  21.     public static void main(String[] args) {
  22.         test();
  23.     }
  25.     /**
  26.      * 测试
  27.      */
  28.     static void test() {
  29.         AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);
  31.         Thread thread1 = new Thread(() -> {
  32.             int[] stampHolder = new int[1];
  33.             int value = atomicStampedReference.get(stampHolder);
  34.             int stamp = stampHolder[0];
  36.             System.out.printf("thread-1 read value:%s,stamp:%s \n", value, stamp);
  37.             try {
  38.                 TimeUnit.SECONDS.sleep(1);
  39.             } catch (InterruptedException e) {
  40.                 e.printStackTrace();
  41.             }
  42.             if (atomicStampedReference.compareAndSet(value, 3, stamp, stamp + 1)) {
  43.                 System.out.printf("thread-1 update from %s to 3\n", value);
  44.             } else {
  45.                 System.out.println("thread-1 update fail");
  46.             }
  47.         });
  49.         Thread thread2 = new Thread(() -> {
  50.             int[] stampHolder = new int[1];
  51.             int value = atomicStampedReference.get(stampHolder);
  52.             int stamp = stampHolder[0];
  53.             System.out.printf("thread-2 read value:%s,stamp:%s\n", value, stamp);
  54.             if (atomicStampedReference.compareAndSet(value, 2, stamp, stamp + 1)) {
  55.                 System.out.printf("thread-2 update from %s\n", value);
  56.                 value = atomicStampedReference.get(stampHolder);
  57.                 stamp = stampHolder[0];
  58.                 System.out.printf("thread-2 read value:%s,stamp:%s\n", value, stamp);
  59.                 if (atomicStampedReference.compareAndSet(value, 1, stamp, stamp + 1)) {
  60.                     System.out.printf("thread-2 update from %s to 1\n", value);
  61.                 }
  62.             }
  63.         });
  65.         thread1.start();
  66.         thread2.start();
  67.     }
  68. }

输出结果：

  1. thread-1 read value:1,stamp:1 
  2. thread-2 read value:1,stamp:1
  3. thread-2 update from 1
  4. thread-2 read value:2,stamp:2
  5. thread-2 update from 2 to 1
  6. thread-1 update fail

很好的通过版本解决了ABA问题。

参考文档：