unsafe 介绍（二）与CAS

在 Oracle JDK 8 中，找不到 unsafe.java，在 idea 中只能由 unsafe.class 反编译得到一个 unsafe.java。

解压openjdk-8u41-src-b04-14_jan_2020.zip，查看 .\openjdk\jdk\src\share\classes\sun\misc\unsafe.java。

这里我也将 unsafe.java 单独导出成 JavaDoc。

可以进我公众号：**【Java与大数据进阶】**下载openjdk 以及单独导出的 unsafe api。

本文只介绍 Unsafe 中与CAS有关的内容，Unsafe 其他内容请见 Unsafe 介绍（一）。

1 CAS 介绍

1.1 定义

CAS(位置V，预期值A，新值B)，即 CompareAndSwap，比较并交换。

首先判断 V 处的值是否是 A，如果还是 A，则将 V 处的值换为 B；否则，不处理。

单线程的时候肯定没有问题。在多线程中，某个线程执行 CAS 之前，位置 V 处的值可能已经改了，这时候就不会处理；如果一定要用 CAS 处理，那就要执行循环，直到某一次修改成功才退出。

底层是 CPU 的 cmpxchg 指令，利用硬件来实现。

CAS 可以保证原子性，这里原子性指的是整个操作不被打断。

1.2 ABA 问题

一个线程读取到 A，如果在 CAS 执行前其他线程将该位置修改为 B，再改回 A，这个线程执行 CAS 操作会认为没有别的线程修改该位置，就会正常执行。

如果不影响结果，ABA 问题不需要处理。否则，必须处理，通常使用加时间戳的 AtomicStampedReference，具体实现见我后续文章的源码讲解。

不影响结果的例子：有三个线程 C,D,E，C 和 D 对 V 处的值加 1 执行100次，E 对 V 处的值减 1 执行100次。如果 C 先获取当前结果为 0，接着 D 和 E 修改了 V 处的值，过程为 0->1->0，这就是 ABA 问题，如果以最终结果来看，不需要处理。

影响结果的例子：初始栈状态有三个元素，有线程 C 和 D，线程 C 想将栈顶的 A 修改为 A2，执行 CAS 操作。如果 C 在执行 CAS 之前，D 先将 A，B 出栈，然后将 A 进栈；C 的 CAS 是发现不了栈已经修改了的，但是这个时候修改和在栈初始状态的时候修改完全是不一样的概念。

2 Unsafe 中的CAS

2.1 基本方法

Unsafe 中最基本的 CAS 是下面三个，即 compareAndSwapObject/Int/Long，这里的地址 V 是用双地址表示的，即对象 o 和偏移量 offset。

底层实现见 https://www.jianshu.com/p/2985b7495522

public final native boolean compareAndSwapObject(Object o, long offset,
                                                     Object expected,
                                                     Object x);

public final native boolean compareAndSwapInt(Object o, long offset,
                                                  int expected,
                                                  int x);

public final native boolean compareAndSwapLong(Object o, long offset,
                                                   long expected,
                                                   long x);

2.2 扩展方法

下面的方法都是使用上面的三个方法，分别获取对应的值，并执行添加或修改操作，具体操作都是放在一个 while 循环里的，保证原子性。

// 先获取再添加
public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }
    
public final long getAndAddLong(Object o, long offset, long delta) {
        long v;
        do {
            v = getLongVolatile(o, offset);
        } while (!compareAndSwapLong(o, offset, v, v + delta));
        return v;
    }
// 先获取再修改
public final int getAndSetInt(Object o, long offset, int newValue) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, newValue));
        return v;
    }
    
public final long getAndSetLong(Object o, long offset, long newValue) {
        long v;
        do {
            v = getLongVolatile(o, offset);
        } while (!compareAndSwapLong(o, offset, v, newValue));
        return v;
    }

public final Object getAndSetObject(Object o, long offset, Object newValue) {
        Object v;
        do {
            v = getObjectVolatile(o, offset);
        } while (!compareAndSwapObject(o, offset, v, newValue));
        return v;
    }

2.3 解释

新的方法如果需要保证原子性，只需要在 while 循环中判断 2.1 中的某个方法即可，而循环体内部可以很复杂。

在不出现 ABA 的情况下，如果没有执行完循环就被其他线程改变了期望的值 v，则循环需要继续；否则，会结束循环。

在 2.2 中的方法都很简单，只是获取，不做一些额外的运算，这是因为做的运算越少，与别的线程冲突的概率就越小，也就越容易结束循环。

如果循环体内部很复杂，比如执行一次循环需要十分钟，那么在这十分钟内，只要有一个线程修改了期望值，那就一切白费，需要重新计算。这种情况冲突概率大，用 synchronized 更好。

CAS 是乐观锁，适用于冲突概率较低的情形。

do{
  ...
}while(!compareAndSwapObject(o, offset, v, newValue))