【尚硅谷周阳--JUC并发编程】【第八章--CAS】

一、原子类

java.util.concurrent.atomic

二、没有CAS之前

1. 多线程环境下不使用原子类保证县城安全i++(基本数据类型)

public class T3 {

    volatile int number = 0;

    // 读取
    public int getNumber() {
        return number;
    }

    // 写入加锁，保证数据原子性
    public synchronized void setNumber() {
        number++;
    }
}

三、使用CAS之后

1. 多线程环境下使用原子类保证线程安全i++(基本数据类型)
2. 类似乐观锁

public class T3 {

    AtomicInteger atomicInteger =  new AtomicInteger();

    public int getAtomicInteger() {
        return atomicInteger.get();
    }

    public void setAtomicInteger() {
        atomicInteger.getAndIncrement();
    }
}

四、是什么？

1、说明

1. CAS（compare and swap的缩写），中文翻译成比较并转换，实现并发算法时常用到的一种技术。
2. 它包含三个操作数–内存位置、预期原值及更新值
3. 执行CAS操作的时候，将内存位置的值与预期原值比较
   • 如果相匹配，那么处理器会自动将该位置值更新为新值
   • 如果不匹配，处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功

2、原理

1. CAS（CompareAndSwap）有三个操作数，位置内存值V，旧的预期值A，要修改的更新值B。
   • 当且仅当旧的预期值A于内存值V相同时，将内存值V修改为B，否则什么都不做或重来
   • 当它重来重试的这种行为称为----自旋！！
     

3、CAS案例

public class CASDemo {
    public static void main(String[] args) {
        // 设置初始值为5
        AtomicInteger atomicInteger = new AtomicInteger(5);

        // 调用compareAndSet方法，传入两个参数，一个是期望值，一个是更新值，若期望值与初始值相同则更新，否则不更新
        boolean flag = atomicInteger.compareAndSet(6, 6);

        System.out.println("比较结果：" + flag + ", 执行完后原子值：" + atomicInteger.get());
    }
}

4、硬件级别保证

1. CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性，它是非阻塞的且自身具有原子性，也就是说它的效率更高且通过硬件保证，说明它很可靠
2. CAS是一条CPU的原子指令(cmpxchg指令)，不会造成所谓的数据不一致问题，Unsafe提供的CAS方法(如compareAndSwapXXX)底层实现即为CPU指令cmpxchg
3. 执行cmpxchg指令的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行CAS操作，也就是说CAS的原子性实际上是CAS实现独占的，比起用synchronized重量级锁，这里的排他时间要短很多，所以在多线程情况下性能会比较好。

5、源码分析compareAndSet(int expect, int update)

五、CAS底层原理

1、UnSafe

1. UnSafe类是CAS的核心类，由于Java无法直接访问底层系统，需要通过本地(native)方法来访问，UnSafe相当于一个后门，基于该类可以直接操作特定内存的数据。UnSafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于UnSafe类的方法。
2. 注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务
3. 变量valueOffset，表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的
   
4. 变量value用volatile修饰，保证了多线程之间的内存可见性

2、atomicInteger.getAndIncrement()不加锁为什么能线程安全

1. CAS的全称是Compare-And-Swap，它是一条CPU并发原语。
2. 它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的
3. AtomicInteger类主要利用CAS(compare and swap) + volatile和native方法来保证原子操作，从而避免synchornized的高开销，执行效率大为提升。
   
   • CAS并发原语体现在Java语言中就是sun.misc.Unsafe类中的各个方法。调用Unsafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被打断，也就是说CAS是一条CPU原子指令，不会造成所谓的数据不一致问题。
   • 注意其中的do while是为了实现自旋

3、源码分析

1. 假设线程A和线程B两个线程同时执行getAndAddInt操作(分别跑在不同CPU上)：

   • AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一分值为3的value的副本分别到各自的工作内存。
   • 线程A通过getIntVolatile(var1, var2)拿到value值3，这时线程A被挂起
   • 线程B也通过getIntVolatile(var1, var2)方法获取到value值3，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为3，成功修改内存值为4，线程B完成，一切正常。
   • 这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值已经被其他线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了。

2. 在调用compareAndSwapInt方法时

   • 参数var1通常代表要进行操作的对象，var2代表要进行操作的字段的偏移量，var5代表期望值，var5 + var4代表更新值。内存值的获取是通过对象var1和偏移量var2来确定的。
   • Unsafe类提供了一种方式来操作特定偏移量处的内存值，它可以通过偏移量直接访问对象的内存地址。因此，在调用compareAndSwapInt方法时，内存值是通过var1对象和var2偏移量来确定的。这样就可以实现对指定内存位置的原子性比较和交换操作。

4、底层汇编

1. native修饰的方法代表是底层方法
   
2. cmpxchg方法
   
   不同的操作系统下会调用不同的cmpxchg重载函数，本次用win10系统为例
   

5、总结

CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性，实现方式是基于硬件平台的汇编指令，在intel的CPU中(X86机器上)，使用的是汇编指令cmpxchg指令。
核心思想就是，比较要更新变量的值V和预期值E(compare)，相等才会将V的值设为新值N（swap）如果不相等自旋在来。

六、原子引用

1. AtomicInteger原子整形，能否自定义其他原子类型呢？答案是肯定的，案例如下

@Getter
@ToString
@AllArgsConstructor
class User {

    String userName;

    int age;

}
public class AtomicReferenceDemo {

    public static void main(String[] args) {
        AtomicReference<User> atomicReference = new AtomicReference<>();

        User z3 = new User("z3", 22);
        User li4 = new User("li4", 28);

        atomicReference.set(z3);
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
    }
}

七、CAS与自旋锁(SpinLock)，借鉴CAS思想

1、是什么？

1. 自旋锁(SpinLock)
   • CAS是实现自旋锁的基础，CAS利用CPU指令保证了操作的原子性，以达到锁的效果，至于自旋呢，看字面意思也很明白，自己旋转。是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU
2. OpenJDK源码里面查看下Unsafe.java
   • CAS是实现自旋锁的基础，自旋翻译下来就是循环，一般是用一个无限循环实现。这样一来，一个无限循环中，执行一个CAS操作
     • 当操作成功返回true时，循环结束
     • 当返回false时，接着执行循环，继续尝试CAS操作，直到返回true
       

2、自定义自旋锁SpinLockDemo

/**
 * 题目：实现一个自旋锁，复习CAS思想
 * 自旋锁好处：循环比较获取没有类似wait的阻塞
 *
 * 通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒，B随后进来后发现
 * 当前有现成持有锁，所以只能通过自旋等待，直到A释放锁后B随后抢到
 *
 * @author 匍匐丶前行
 * @since 2024/3/19 15:25
 **/

public class SpinLockDemo {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void lock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
        while (!atomicReference.compareAndSet(null, thread)) {

        }
        System.out.println(Thread.currentThread().getName() + "\t" + "------拿到资源");
    }

    public void unlock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName() + "\t" + "------task over");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.lock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            spinLockDemo.unlock();
        }, "A").start();

        // 保证线程A先启动
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }


        new Thread(() -> {
            spinLockDemo.lock();
            try {
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            spinLockDemo.unlock();
        },"B").start();

    }
}

八、CAS缺点

1、循环时间长开销很大

1. 从getAndAddInt方法源码中可以看到有一个do while。如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销
   

2、引出来ABA问题

2.1、ABA问题怎么产生的？

1. CAS会导致“ABA问题”
   • CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差内会导致数据的变化。
   • 比如说一个线程1从内存位置V中取出A，这时候另一个线程2也从内存中取出A，并且线程2进行了一些操作将值编程了B，然后线程2又将V位置的数据编程A，这时候线程1进行CAS操作发现内存中任然是A，预期没有问题，然后线程1操作成功
   • 尽管线程1的CAS操作成功，但是不代表这个过程就是没有问题的。

2.2、版本号时间戳原子引用

• AtomicStampedReference单线程版本

@AllArgsConstructor
@NoArgsConstructor
@Data
class Book {
    private int id;

    private String bookName;
}

public class AtomicStampedDemo {

    public static void main(String[] args) {

        Book javaBook = new Book(1, "javaBook");

        AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<Book>(javaBook, 1);

        System.out.println(stampedReference.getReference() + "\t" + stampedReference.getStamp());

        Book mysqlBook = new Book(2, "mysqlBook");

        boolean b;

        b = stampedReference.compareAndSet(javaBook, mysqlBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);

        System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());

        b = stampedReference.compareAndSet(mysqlBook, javaBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);

        System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());

    }
}

• 多线程使用AtomicInteger 情况下会出现ABA问题，因为只比较了内容，未比较版本。

public class ABADemo {
    static AtomicInteger atomicInteger = new AtomicInteger(100);
    public static void main(String[] args) {
        new Thread(() -> {
            atomicInteger.compareAndSet(100, 101);

            try {
                TimeUnit.MILLISECONDS.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            atomicInteger.compareAndSet(101, 100);
        }, "t1").start();


        new Thread(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(atomicInteger.compareAndSet(100, 2024) + "\t" + atomicInteger.get());
        }, "t2").start();
    }
}

• 多线程使用AtomicStampedInteger 情况下不会出现ABA问题，因为不仅比较了内容，也比较了版本。

public class ABADemo {
    static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100, 1);
    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号：" + stamp);

            // 暂停500毫秒，保证后面的t4线程初始化拿到的版本号和当前线程一致
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            stampedReference.compareAndSet(100, 101, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "二次版本号：" + stampedReference.getStamp());

            stampedReference.compareAndSet(101, 100, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "三次版本号：" + stampedReference.getStamp());

        }, "t1").start();

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号：" + stamp);

            // 等待t1线程发生ABA问题
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            boolean b = stampedReference.compareAndSet(100, 2024, stamp, stampedReference.getStamp() + 1);
            System.out.println(b + "\t" + Thread.currentThread().getName() + "\t" + "二次版本号：" + stampedReference.getStamp());
        }, "t2").start();
    }
}

3、总结

推荐使用AtomicStampedReference，同时比较内容和版本号。