【JUC】CAS（轻量级加锁）

原子类

Java.util.concurrent.atomic

没有CAS之前

多线程环境中加锁保证线程安全i++（重量级锁，性能可能没有这么好）

class Test {
    private volatile int count = 0;
    
    public int getCount() {
        return count;
    }
    
    // 需要加锁保证count++的原子性
    public synchronized void increment() {
        count++;
    }
}

使用CAS之后

多线程环境中使用原子类保证线程安全i++，类似于乐观锁

class Test2 {
    private AtomicInteger count = new AtomicInteger();
    public void increment() {
        count.incrementAndGet();
    }
    // 使用AtomicInteger之后，不需要加锁，也可以实现线程安全
    public int getCount() {
        return count.get();
    }
}

CAS是什么？

• CAS(compare and swap)，中文翻译为比较并交换，实现并发算法时常用到的一种技术，用于保证共享变量的原子性更新。
• 执行CAS操作的时候，将内存位置的值与预期原值进行比较：
  • 如果相匹配，那么处理器会自动将该位置更新为新值
  • 如果不匹配，处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功
• CAS有3个操作数，位置内存值V，旧的预期值A，要修改的更新值B。当且仅当旧的预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做或重来，重试的这种行为称为自旋

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

compareAndSet 源码

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        // 如果atomicInteger与期望值5相同，就将值设置为2022
        System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());//true        2022
        System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());//false        2022
    }
}

valueOffset被用来告诉Unsafe.compareAndSwapInt方法在当前对象（this）中要操作的字段的确切位置。compareAndSwapInt是一个原子操作，它尝试将对象中指定偏移量处的整型字段从期望值（expect）更新为新值（update），只有在当前值确实等于期望值时才会进行更新。

CAS底层原理？谈谈对Unsafe类的理解？

Unsafe

Unsafe类是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因此Java中CAS操作的执行依赖于Unsafe类的方法。

原子版的i++，值更新之后，怎么刷新到主内存，value是volatile修饰的，保证了多线程之间的内存可见性

注意：Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的所有方法都直接调用操作系统底层资源执行相应任务。

i++是线程不安全的，AtomicInteger.getAndIncrement()如何保证原子性？

• CAS的全称为Compare-And-Swap，它是一条CPU并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。
• AtomicInteger类主要利用CAS+volatile和native方法来保证原子操作，从而避免synchronized的高开销，执行效率大为提升：

CAS并发原语体现在Java语言中就是sun.misc.Unsafe类中的各个方法。调用Unsafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

源码分析

假设线程A和线程B两个线程同时执行getAndAddlnt操作（分别跑在不同CPU上）：

1、假如AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各目持有一份值为3的value的副本分别到各自的工作内存。

2、线程A通过getlntVolatile(var1, var2)拿到value值3，这时线程A被挂起（CPU轮询）。

3、线程B也通过getlntVolatile(var1,var2)方法获取到value值3，此时刚好线程B没有被挂起并执compareAndSwaplnt万法比较内存值也为3，成功修改内存值次4，线程B结束，一切OK

4、 这时线程A恢复，执行compareAndSwaplnt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值已经被其它线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了

5、线程A重新获取value，因为变量value被volatile修饰，所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwaplnt进行比较替换，直到成功

底层汇编语言

JDK提供的CAS机制，在汇编层级会禁止变量两侧的指令优化，然后使用compxchg指令比较并更新变量值（原子性）

面试回答

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

原子引用AtomicReference

【AtomicReference基础使用案例】

@Data
@AllArgsConstructor
@NoArgsConstructor
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);
        // 初始化为z3
        atomicReference.set(z3);
        // 如果还是值是z3，修改为li4
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
    }
}

自旋锁SpinLock（借鉴CAS思想）

自旋锁是什么？

CAS是实现自旋锁的基础，CAS利用CPU指令保证了操作的原子性，以达到锁的效果，至于自旋锁（自旋就是循坏，一般是用一个无限循环实现。一个无限循坏中，执行一个CAS 操作，当操作成功返回true时，循环结束；当返回 false时，接着执行循坏，继续尝试 CAS 操作，直到返回 true），是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取到锁。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

案例：实现一个自旋锁

题目：实现一个自旋锁，借鉴CAS思想。通过CAS完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒钟，B随后进来后发现当前有线程持有锁，所以只能通过自旋等待，直到A释放锁后B随后抢到。

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)) {
        }
    }
    public void unLock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName() + "\t ----task over,unLock...");
    }
    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(() -> {
            spinLockDemo.lock();
            // 花5秒实现业务
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.unLock();
        }, "A").start();
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            spinLockDemo.lock();
            spinLockDemo.unLock();
        }, "B").start();
    }
}

A一开始占用了锁，B一直在自旋，等待A结束业务释放锁，B就能获取到锁，来执行自己的业务

CAS缺点

循环时间长开销很大

• getAndAddInt方法有一个do while
• 如果CAS失败，会一直进行尝试，如果CAS长时间一直不成功，可能会给CPU带来很大开销

可能出现ABA问题

• ABA问题怎么产生的？
  • CAS算法实现一个重要前提需要提取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。
  • 比如说一个线程1从内存位置V中取出A，这时候另一个线程2也从内存中取出A，并且线程2进行了一些操作将值变成了B，然后线程2又将V位置的数据变成A，这时候线程1进行CAS操作发现内存中仍然是A，和预期一样，线程1操作成功。尽管线程1的CAS操作成功，但是不代表这个过程就是没有问题的（如在一些事务处理或状态机中，如果一个操作需要撤销，而撤销操作依赖于CAS来检测操作是否已经被另一个线程执行，ABA问题可能导致撤销操作误以为原操作没有执行而实际上已经被执行了）

AtomicStampedReference解决ABA问题

版本号时间戳原子引用

public boolean compareAndSet(V   expectedReference,
                             V   newReference,
                             int expectedStamp,
                             int newStamp) {}

【入门案例】

@Data
@AllArgsConstructor
@NoArgsConstructor
class Book {
    private int id;
    private String bookName;
}
public class AtomicStampedReferenceDemo {
    public static void main(String[] args) {
        Book javaBook = new Book(1, "javaBook");
        // 版本号初始化为 1
        AtomicStampedReference<Book> atomicStampedReference = new AtomicStampedReference<>(javaBook, 1);
        System.out.println(atomicStampedReference.getReference() + "\t" + atomicStampedReference.getStamp());
        Book mysqlBook = new Book(2, "mysqlBook");
        boolean b;
        // 修改成功，版本号加1
        b = atomicStampedReference.compareAndSet(javaBook, mysqlBook, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
        System.out.println(b + "\t" + atomicStampedReference.getReference() + "\t" + atomicStampedReference.getStamp());
        b = atomicStampedReference.compareAndSet(mysqlBook, javaBook, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
        System.out.println(b + "\t" + atomicStampedReference.getReference() + "\t" + atomicStampedReference.getStamp());
    }
}

虽然值改过又改回来，但是有版本号加持，可以知道值已经被修改过

【复杂案例】

多线程情况下演示AtomicStampedReference解决ABA问题

public class ABADemo {
    // 不带版本号
    static AtomicInteger atomicInteger = new AtomicInteger(100);
    // 带版本号
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);
    public static void main(String[] args) {
//        abaHappen();//true        2023
        abaNoHappen();
    }
    
    
    private static void abaNoHappen() {
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号: " + stamp);
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "2次版本号: " + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "3次版本号: " + atomicStampedReference.getStamp());
        }, "t3").start();
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号: " + stamp);
            // 暂停1秒钟，等待t3线程发生ABA问题
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean b = atomicStampedReference.compareAndSet(100, 200, stamp, stamp + 1);
            System.out.println(b + "\t" + atomicStampedReference.getReference() + "\t" + atomicStampedReference.getStamp());
        }, "t4").start();
    }
    
    // 不带版本号的版本
    private static void abaHappen() {
        new Thread(() -> {
            atomicInteger.compareAndSet(100, 101);
            try {
                TimeUnit.MILLISECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicInteger.compareAndSet(101, 100);
        }, "t1").start();
        new Thread(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicInteger.compareAndSet(100, 2023) + "\t" + atomicInteger.get());//true        2023
        }, "t2").start();
    }
}

• 一句话：比较的时候，加版本号一起比

文章说明

该文章是本人学习 尚硅谷 的学习笔记，文章中大部分内容来源于 尚硅谷 的视频尚硅谷JUC并发编程（对标阿里P6-P7），也有部分内容来自于自己的思考，发布文章是想帮助其他学习的人更方便地整理自己的笔记或者直接通过文章学习相关知识，如有侵权请联系删除，最后对 尚硅谷 的优质课程表示感谢。