java学习记录CAS乐观锁

Z时代
2024-01-10
分类：综合

下面看个图简单理解一下CAS：当线程1和线程2同时操作内存V，线程1想要把内存V的变量值从A(2)改成B(1)而线程2想要把V的变量值从A(2)改成B(3)。假设这个时候是线程1优先抢到资源所以线程1先进行CAS操作，这个时候预期旧值2是相等的则执行了更新，更新完后内存V的变量值就变成1，这个时候线程2才进入比较预期的A值与V中实际的变量值已经不相同了，所以更新失败。

这个图看上去是Compare And Swap 是同时操作，但实际上是分2部执行：1.比较(compare)，2.交换(swap),它的原子性是通过硬件实现的，而不是我们java代码实现

java提供的CAS操作类

我们随便找其中一个Atomic类学习

当V的值与A相等则更新成功

public static void main(String[] args) {
// 定义Integer的CAS类
AtomicInteger AI = new AtomicInteger();
// 设置初始化值
AI.set(1);
// 将 1 替换成 2 并返回是否替换成功,该函数第一个参数为预期的旧值(A)，第二个参数是需要修改的值(B)
boolean b = AI.compareAndSet(1, 2);
// 打印是否替换成功
System.out.println(b);
// 打印最新值
System.out.println(AI);
}

打印结果：

当V的值与A不相等则更新失败

public static void main(String[] args) {
// 定义Integer的CAS类
AtomicInteger AI = new AtomicInteger();
// 设置初始化值
AI.set(1);
// 将 1 替换成 2 并返回是否替换成功，该函数第一个参数为预期的旧值(A)，第二个参数是需要修改的值(B)
boolean b = AI.compareAndSet(2, 2);
// 打印是否替换成功
System.out.println(b);
// 打印最新值
System.out.println(AI);
}

打印结果：

这2个打印结果的结论也证实了最开始那个图的原理，只有V的变量值与A相同时候，才会修改成B ，

接下来看看原子性

普通的int类型

public class AmIntegerTest implements Runnable {
    private static volatile int I = 0;
    public void run() {
// 每个线程自增100000次，
for (int i = 0; i++ < 100000; add()) {}
// 线程执行完之后结果
System.out.println(Thread.currentThread().getName() + ":" + I);
    }
    public static void add(){
I++;
    }
    public static void main(String[] args) {
        AmIntegerTest ait = new AmIntegerTest();
        Thread t1 = new Thread(ait);
        Thread t2 = new Thread(ait);
        t1.start();
        t2.start();
    }
}

打印结果显示，普通的int没有原子性

除非加上synchronized 关键字，接下来改造add()添加synchronized其他代码不变

public synchronized static void add(){
I++;
}

无论执行多少次最终结果都是200000，可以保证原子性

我们再看看java提供的CAS操作类

public class AmIntegerTest implements Runnable {
// 定义Integer的CAS类
private static AtomicInteger AI = new AtomicInteger();
    public void run() {
// 每个线程自增100000次，
for (int i = 0;i++ < 100000; AI.incrementAndGet()) {}
// 线程执行完之后结果
System.out.println(Thread.currentThread().getName() + ":" + AI.get());
    }
    public static void main(String[] args) {
        AmIntegerTest ait = new AmIntegerTest();
        Thread t1 = new Thread(ait);
        Thread t2 = new Thread(ait);
        t1.start();
        t2.start();
    }
}

无论执行多少次最终结果都是200000，所以是具有原子性的，但是它的原子性是其他语言实现的，这里就不讨论它的实现原理了(我不会C++)

AtomicInteger.value是一个volatile 修饰的变量（内存锁定，同一时刻只有一个线程可以修改内存值）

private volatile int value;

AtomicInteger.incrementAndGet()这是一个自增函数，实现了自旋锁(无限循环)，下面看看incrementAndGet()的源代码，它调用了Unsafe 类的getAndAddInt()。而getAndAddInt()是无限循环，直到值修改成功才结束，否则一直循环

public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

private static final Unsafe unsafe = Unsafe.getUnsafe();

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}

getAndAddInt()实现的自旋锁原理就是内存V的变量值与A不一致时候，再重新获取V的变量值，直到V的变量值与A一致时候，才更新成B并结束，这样有个缺点就是如果自旋次数太多，会造成很大的资源消耗

在Atomic包中的CAS操作都是基于以下3个方法实现，Unsafe类里面的所有方法都是 native 声明的，说明是调用其他语言实现的

//第一个参数o为给定对象，offset为对象内存的偏移量，通过这个偏移量迅速定位字段并设置或获取该字段的值，//expected表示期望值，x表示要设置的值，下面3个方法都通过CAS原子指令执行操作。
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);

我们试试使用一下这些函数

public class CasTest {
// 定义java 的CAS类Unsafe
public static Unsafe U = getUnsafe();
    public static void main(String[] args) throws NoSuchFieldException {
// java Unsafe类调用C++ 实现的CAS
        // 创建一个我们的测试对象
Cas cas = new Cas("1");
// 获取对象内value存储对象的地址
long offset = U.objectFieldOffset(cas.getClass().getDeclaredField("value"));
// 通过Unsafe类的CAS函数进行修改
System.out.println(U.compareAndSwapObject(cas, offset, "1", "2"));
System.out.println(cas);
}
static class Cas{
private String value;
        public Cas(String value) {
this.value = value;
}
@Override
public String toString() {
return "Cas{" +
"value="" + value + """ +
"}";
}
    }
// 因为 Unsafe的构造函数是私有的,而且它提供的 getUnsafe()也只有系统类才能使用，
// 所以我们只能通过反射获取Unsafe实例了
private static Unsafe getUnsafe() {
        Unsafe unsafe = null;
        try {
            Constructor<?> declaredConstructor = Unsafe.class.getDeclaredConstructors()[0];
declaredConstructor.setAccessible(true);
unsafe = (Unsafe) declaredConstructor.newInstance();
} catch (Exception e) { e.printStackTrace(); }
return unsafe;
}
}

看一下main()的打印结果，修改cas对象的value值，从“1”改成“2”，执行成功

改一下main()，试一下从“2”改成“2”

public static void main(String[] args) throws NoSuchFieldException {
// java Unsafe类调用C++ 实现的CAS
    // 创建一个我们的测试对象
Cas cas = new Cas("1");
// 获取对象内value存储对象的地址
long offset = U.objectFieldOffset(cas.getClass().getDeclaredField("value"));
// 通过Unsafe类的CAS函数进行修改
System.out.println(U.compareAndSwapObject(cas, offset, "2", "2"));
System.out.println(cas);
}

这个时候修改是失败的，因为value的值为“1”，而CAS操作里预期的旧值是“2”，所以无法成功执行从“2”改成“2”

下面2个函数都是Unsafe类里面的，都是私有的，而且它提供的 getUnsafe()也不能使用，所以需要通过反射获取实例

private Unsafe() {
}
@CallerSensitive
public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}

ABA问题

ABA就是内存V的变量值从A变成B，再从B变成A，这个时候CAS只判断值是否相等，只要值相等就会认为这个值没改变过，但实际上是已经变化了。我们可以添加多一个标识(版本号、时间)判断这个值是否已经改变过，java也提供了相关的解决方案 AtomicStampedReference 类。

先看一下普通CAS的操作类

public static void main(String[] args) {
// 定义Integer的CAS类
AtomicInteger AI = new AtomicInteger(1);
    System.out.println("初始化值：" + AI);
    AI.compareAndSet(1,2);
    System.out.println("第一次CAS操作完成之后值：" + AI);
    AI.compareAndSet(2,1);
    System.out.println("第二次CAS操作完成之后值：" + AI);
    AI.compareAndSet(1,3);
    System.out.println("第二次CAS操作完成之后值：" + AI);
}

这种只需要V的值与A一致就可以修改，存在ABA问题

接下来看看CAS的标识引用类

public static void main(String[] args) {
// 定义 AtomicStampedReference 类，第一个参数是我们的初始化值，第二个是版本标识
AtomicStampedReference<Integer> ASR = new AtomicStampedReference<Integer>(1,1);
    System.out.println("初始化值：" + ASR.getReference());
    ASR.compareAndSet(1,2, ASR.getStamp(), ASR.getStamp() + 1);
    System.out.println("第一次CAS操作完成之后值：" + ASR.getReference());
// 获取stamp ,下面2次新增都使用这个 stamp值
int stamp = ASR.getStamp();
// 这一次可以修改成功，因为 stamp 的预期值一致
ASR.compareAndSet(2,1, stamp, stamp + 1);
    System.out.println("第二次CAS操作完成之后值：" + ASR.getReference());
// 这一次可以修改失败，因为 stamp 的预期值不一致
ASR.compareAndSet(1,3, stamp, stamp + 1);
    System.out.println("第三次CAS操作完成之后值：" + ASR.getReference());
}