JUC并发编程学习笔记（十八）深入理解CAS

合集 - JUC并发编程(20)

1.JUC并发编程学习笔记（二）Lock锁(重点)2023-11-022.JUC并发编程学习笔记（一）认知进程和线程2023-11-023.JUC并发编程学习笔记（三）生产者和消费者问题2023-11-024.JUC并发编程学习笔记（四）8锁现象2023-11-025.JUC并发编程学习（五）集合类不安全2023-11-036.JUC并发编程学习笔记（六）Callable(简单)2023-11-037.JUC并发编程学习笔记（七）常用的辅助类2023-11-048.JUC并发编程学习笔记（八）读写锁2023-11-049.JUC并发编程学习笔记（九）阻塞队列2023-11-0410.JUC并发编程学习笔记（十）线程池（重点）2023-11-0411.JUC并发编程学习（十一）四大函数式接口（必备）2023-11-0512.JUC并发编程学习笔记（十二）Stream流式计算2023-11-0513.JUC并发编程学习（十三）ForkJoin2023-11-0614.JUC并发编程学习笔记（十四）异步回调2023-11-0615.JUC并发编程学习笔记（十五）JMM2023-11-0716.JUC并发编程学习笔记（十七）彻底玩转单例模式2023-11-0917.JUC并发编程学习笔记（十九）原子引用2023-11-1418.JUC并发编程（终章）各种锁的理解2023-11-1619.JUC并发编程学习笔记（十六）Volatile2023-11-08

20.JUC并发编程学习笔记（十八）深入理解CAS2023-11-10

收起

深入理解CAS

什么是CAS

为什么要学CAS：大厂你必须深入研究底层！有所突破！

java层面的cas------->compareAndSet

compareAndSet(int expectedValue, int newValue) 期望并更新，达到期望值就更新、否则就不更新！

package org.example.cas;
 
import java.util.concurrent.atomic.AtomicInteger;
 
public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        //JAVA CAS -> 比较并交换
        //期望、更新
        //compareAndSet(int expectedValue, int newValue)
        //如果我期望的值达到了那么就跟新、否则就不更新；CAS 是CPU的并发原语！
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        //达到期望值更新成功
        System.out.println(atomicInteger.get());
        //更新后未达到期望值，更新失败
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

Unsafe类

java不能直接操作内存，但是可以调用c++，c++可以操作内存，java可以通过native关键字定义的方法来调用c++。Unsafe类就像是java留给自己的一个后门。所以Unsafe类中都是native方法和调用native方法的方法！

在原子类里，有一个getAndIncrement方法用作自增、那么他的底层是如何实现的呢？

其实就是调用的unsafe类中的getAndAddInt方法

public final int getAndIncrement() {
    //dalta传入了1
    return U.getAndAddInt(this, VALUE, 1);
}

public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        //v每次都跟新为最新值，所以一直会是期望的值！就执行了++的操作
        v = getIntVolatile(o, offset);
        //如果当前对象o期望的值等于v，那么将当前对象o的值跟新为v+dalta；
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    return v;
}

public final boolean weakCompareAndSetInt(Object o, long offset,
                                              int expected,
                                              int x) {
        return compareAndSetInt(o, offset, expected, x);
    }

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

对比观察，其实getAndAddInt就是定义一个变量取到最新的值，然后通过while循环一直更新，其中getIntVolatile和compareAndSetInt都是通过java调用底层c++操作内存。

其中用到了一段标准的锁（自旋锁！）：

 do {
        //v每次都跟新为最新值，所以一直会是期望的值！就执行了++的操作
        v = getIntVolatile(o, offset);
        //如果当前对象o期望的值等于v，那么将当前对象o的值跟新为v+dalta；
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));

缺点

1、循环会耗时

2、一次性只能保证一个共享变量的原子性

3、会存在ABA问题

优点

自带原子性

CAS : ABA问题(狸猫换太子)！

package org.example.cas;
 
import java.util.concurrent.atomic.AtomicInteger;
 
public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        //JAVA CAS -> 比较并交换
        //期望、更新
        //compareAndSet(int expectedValue, int newValue)
        //如果我期望的值达到了那么就跟新、否则就不更新;   CAS 是CPU的并发原语！
        //===============捣乱的线程================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        //达到期望值更新成功
        System.out.println(atomicInteger.get());
        //更新后未达到期望值，更新失败
        //===============期望的线程================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        //getAndIncrement number++ 底层如何实现的？
        atomicInteger.getAndIncrement();//++方法
 
    }
}