深入理解CAS

非阻塞同步之CAS

概念

互斥同步

• 同步是指多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一条（或者是一些，当使用信号量的时候）线程使用；

• 互斥是实现同步的一种手段，临界区、互斥量和信号量都是常见的互斥实现方式。

• **互斥是方法，同步是目的。**互斥同步是一种最常见的也是最主要的并发正确性保障手段。

互斥同步属于一种悲观的并发策略，不论共享的数据是否发生竞争，它都会进行加锁，而这会导致用户态到内核态的转换，因此互斥同步面临的主要问题是进行阻塞唤醒带来的性能开销，同时这种同步方式也被称作阻塞同步。

CAS

随着硬件指令集的发展，我们已经有了其他选择：基于冲突检测的乐观并发策略，通俗地说就是不管风险，先进性操作，如果没有其他线程竞争共享数据操作就直接成功了；如果共享数据的确存在竞争，那再进行其他措施，例如不断重试直到出现没有竞争的共享数据为止。这种乐观并发策略的实现不再需要把线程阻塞挂起，因此这种同步操作被称为非阻塞同步，使用这种措施的代码也被称为无锁编程。

之所以说乐观并发策略需要“硬件指令集的发展”，是因为我们必须要求操作和冲突检测这两个步骤具备原子性。如果再使用互斥同步来保证原子性就完全失去意义了，因此需要依靠硬件来实现这件事，硬件保证某些从语义上看起来需要多次操作的行为可以通过一条处理器指令就能完成，这类指令常用的有：测试并设置、获取并增加、比较并交换（CAS）、加载链接/条件存储（LL/SC）。Java中最终暴露出来的是CAS操作。

CAS算法（compare and swap）,比较并交换，指的是一种原子操作，在不使用锁的情况下，实现线程间的变量同步，所以也叫“非阻塞同步”。

CAS算法涉及到了三个值：

• 主物理内存的值value
• 线程的期望值expect
• 线程的更新值update

if(expect==value){
    value = update;
    return ture;
}else{
    return false;
}

以上伪代码描述的就是比较并交换的复合操作，CAS可以视作以上代码合并后的整体操作，其原子性是由硬件层面来保证的。

应用

在Java中，CAS操作由Unsafe类提供支持，以下方法都是native方法，它们都是 native 方法，由 jvm实现，这意味着不同的 Java 虚拟机对它们的实现可能会略有不同。以 compareAndSwapInt 为例，Unsafe 的 compareAndSwapInt 方法接收 4 个参数，分别是：对象实例、内存偏移量、字段期望值、字段新值。该方法会针对指定对象实例中的相应偏移量的字段执行 CAS 操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VO18YlVU-1649059951075)(E:\file\学习\课后总结\并发编程\assert\unsafe-cas.png)]

public class CASTest {

    public static void main(String[] args) {
        boolean successful;
        Entity entity = new Entity();
        Unsafe unsafe = UnsafeFactory.getUnsafe();
        long offset = UnsafeFactory.getFieldOffset(unsafe, Entity.class, "x");

        successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
        System.out.println(successful + "\t" + entity.x);

        successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
        System.out.println(successful + "\t" + entity.x);

        successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
        System.out.println(successful + "\t" + entity.x);

    }
}


class Entity{
    int x;
}

打印结果

12
true	3
true	5
false	5

源码分析

HotSpot对CompareAndSwapInt的实现如下：

• Atomic::cmpxchg(x, addr, e)方法====>>> x:要交换的值 e:要比较的值。

  cas成功，期望值等于e,此方法返回true;cas失败，返回内存中的value值，不等于e，此方法返回false

#unsafe.cpp
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  // 根据偏移量计算地址
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;

• 核心逻辑在Atomic::cmpxchg方法中，这个根据不同操作系统和不同CPU会有不同的实现。这里我们以linux_64x的为例。
  • 首先会判断当前环境是否为多处理器环境
  • 然后为cmpxchgl 指令添加 lock 前缀，以达到内存屏障的效果
  • cmpxchgl 指令是包含在 x86 架构及 IA-64 架构中的一个==原子条件指令==，
    • 它会首先比较 dest 指针指向的内存值是否和 compare_value 的值相等，如果相等，则双向交换 dest 与 exchange_value，否则就单方面地将 dest 指向的内存值交给exchange_value。
    • 这条指令完成了整个 CAS 操作，因此它也被称为 CAS 指令。

#atomic_linux_x86.inline.hpp
inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  //判断当前执行环境是否为多处理器环境
  int mp = os::is_MP();
  
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");
  return exchange_value;

cmpxchgl的详细执行过程

首先，输入是"r" (exchange_value), “a” (compare_value), “r” (dest), “r” (mp)，表示compare_value存入eax寄存器，而exchange_value、dest、mp的值存入任意的通用寄存器。嵌入式汇编规定把输出和输入寄存器按统一顺序编号，顺序是从输出寄存器序列从左到右从上到下以“%0”开始，分别记为%0、%1···%9。也就是说，输出的eax是%0，输入的exchange_value、compare_value、dest、mp分别是%1、%2、%3、%4。

因此，cmpxchg %1,(%3)实际上表示cmpxchg exchange_value,(dest)

需要注意的是cmpxchg有个隐含操作数eax，其实际过程是先比较eax的值(也就是compare_value)和dest地址所存的值是否相等，

输出是"=a" (exchange_value)，表示把eax中存的值写入exchange_value变量中。

Atomic::cmpxchg这个函数最终返回值是exchange_value，也就是说，如果cmpxchgl执行时compare_value和dest指针指向内存值相等则会使得dest指针指向内存值变成exchange_value，最终eax存的compare_value赋值给了exchange_value变量，即函数最终返回的值是原先的compare_value。此时Unsafe_CompareAndSwapInt的返回值(jint)(Atomic::cmpxchg(x, addr, e)) == e就是true，表明CAS成功。如果cmpxchgl执行时compare_value和(dest)不等则会把当前dest指针指向内存的值写入eax，最终输出时赋值给exchange_value变量作为返回值，导致(jint)(Atomic::cmpxchg(x, addr, e)) == e得到false，表明CAS失败。

现代处理器指令集架构基本上都会提供 CAS 指令，例如 x86 和 IA-64 架构中的 cmpxchgl 指令和 comxchgq 指令，sparc 架构中的 cas 指令和 casx 指令。

不管是 Hotspot 中的 Atomic::cmpxchg 方法，还是 Java 中的 compareAndSwapInt 方法，它们本质上都是对相应平台的 CAS 指令的一层简单封装。CAS 指令作为一种硬件原语，有着天然的原子性，这也正是 CAS 的价值所在。

缺陷

CAS虽然高效的解决了原子性问题，但仍旧存在一些问题：

• 自旋CAS如果长时间不成功，会给CPU带来很大的开销
• 只能保证一个共享变量的原子性操作
• ABA问题

ABA问题

CAS算法在取出内存中的数据和比较并交换两个时刻之间会存在时间差，而这个时间差可能会导致数据的变化。

什么是ABA问题呢？

当有多个线程对一个原子类进行操作的时候，某个线程在短时间内将原子类的值A修改为B，又马上将其修改为A，此时其他线程不感知，还是会修改成功。

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qHEvCf9u-1649059951077)(E:\file\学习\课后总结\并发编程\assert\ABA,png)]

示例：

public class ABATest {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread1 read value: " + value);

            // 阻塞1s
            LockSupport.parkNanos(1000000000L);

            // Thread1通过CAS修改value值为3
            if (atomicInteger.compareAndSet(value, 3)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();

        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread2 read value: " + value);
            // Thread2通过CAS修改value值为2
            if (atomicInteger.compareAndSet(value, 2)) {
                log.debug("Thread2 update from " + value + " to 2");

                // do something
                value = atomicInteger.get();
                log.debug("Thread2 read value: " + value);
                // Thread2通过CAS修改value值为1
                if (atomicInteger.compareAndSet(value, 1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }

解决方案

AtomicStampedReference

数据库有一种基于版本来实现同步的机制，每次修改完数据，版本号就会加一，这是一种乐观锁机制。同样地，Java也提供了相应的原子引用类：AtomicStampReference

public class AtomicStampedReference<V> {

    private static class Pair<T> {
        final T reference;//实际存储的变量
        final int stamp;//版本，每次修改可以通过+1保证版本唯一性。这样就可以保证每次修改后的版本也会往上递增
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }
    
  	private volatile Pair<V> pair;
    
  	public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }
  ...
}

示例：

public class AtomicStampedReferenceTest {

    public static void main(String[] args) {
        // 定义AtomicStampedReference    Pair.reference值为1, Pair.stamp为1
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1,1);

        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread1 read value: " + value + ", stamp: " + stamp);

            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread1通过CAS修改value值为3   stamp是版本，每次修改可以通过+1保证版本唯一性
            if (atomicStampedReference.compareAndSet(value, 3,stamp,stamp+1)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();

        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = (int)atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread2 read value: " + value+ ", stamp: " + stamp);
            // Thread2通过CAS修改value值为2
            if (atomicStampedReference.compareAndSet(value, 2,stamp,stamp+1)) {
                log.debug("Thread2 update from " + value + " to 2");

                // do something

                value = (int) atomicStampedReference.get(stampHolder);
                stamp = stampHolder[0];
                log.debug("Thread2 read value: " + value+ ", stamp: " + stamp);
                // Thread2通过CAS修改value值为1
                if (atomicStampedReference.compareAndSet(value, 1,stamp,stamp+1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }
}

AtomicMarkableReference

AtomicMarkableReference可以理解为上面AtomicStampedReference的简化版，就是不关心修改过几次，仅仅关心是否修改过。因此变量mark是boolean类型，仅记录值是否有过修改。

public class AtomicMarkableReference<V> {

    private static class Pair<T> {
        final T reference;
        final boolean mark;
        private Pair(T reference, boolean mark) {
            this.reference = reference;
            this.mark = mark;
        }
        static <T> Pair<T> of(T reference, boolean mark) {
            return new Pair<T>(reference, mark);
        }
    }

    private volatile Pair<V> pair;

    /**
     * Creates a new {@code AtomicMarkableReference} with the given
     * initial values.
     *
     * @param initialRef the initial reference
     * @param initialMark the initial mark
     */
    public AtomicMarkableReference(V initialRef, boolean initialMark) {
        pair = Pair.of(initialRef, initialMark);
    }

tomicMarkableReference} with the given
* initial values.
*
* @param initialRef the initial reference
* @param initialMark the initial mark
*/
public AtomicMarkableReference(V initialRef, boolean initialMark) {
pair = Pair.of(initialRef, initialMark);
}