第七章 CAS

7.1 原子类

java.util.consurrent.atomic

7.2 没有 CAS 之前

多线程环境中不使用原子类保证线程安全 i++ （基本数据类型）

public class T3 {
    
    volatile int number = 0;
    
    public int getNumber() {
        return number;
    }

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

7.3 使用 CAS 之后

多线程环境中使用原子类保证线程 i++（基本数据类型）-----> 类似乐观锁

public class T3 {

    AtomicInteger atomicInteger = new AtomicInteger();
    
    public int getNumber() {
        return atomicInteger.get();
    }
    
    public void setNumber() {
        atomicInteger.incrementAndGet();
    }
    
}

7.4 是什么？

CAS（compare and swap），中文翻译为比较并交换，实现并发算法时常用到的一种技术，用于保证共享变量的原子性更新，它包含三个操作数-----内存位置、预期原值与更新值

执行 CAS 操作的时候，将内存位置的值与预期值进行比较

如果相匹配，那么处理器会自动将该位置更新为新值
如果不匹配，处理器不做任何操作，多线程同时执行 CAS 操作只有一个会成功

public class CASDemo {

    /**
     * 运行结果：
     * true	2022
     * false	2022
     */
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println(atomicInteger.compareAndSet(5,  2022) + "\t" +atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5,  2022) + "\t" +atomicInteger.get());
    }

}

硬件级别保证（混个眼熟）

CAS 是 JDK 提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性
它是非阻塞的且自身具有原子性，也就是说这玩意效率高且通过硬件保证，说明这玩意是可靠

CAS是一条 CPU 的原子指令（cmpxchg 指令），不会造成所谓的数据不一致问题，Unsafe 提供的 CAS 方法（如 compareAndSwapXXX）底层实现即为 CPU 指令 cmpxchg

执行 cmpxchg 指令的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程对总线加锁成功，加锁成功之后会执行cas 操作，也就是说 CAS 的原子性实际上是 CPU 实现独占的，  比起用 synchronized 重量级锁，这里的排他时间要短很多，所以在多线程情况下性能会比较好

compareAndSet 源码

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

7.5.1 Unsafe

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

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

问题：我们知道 i++ 是线程不安全的，那 AtomicInteger.getAndIncrement()如何保证原子性？

AtomicInteger 类主要利用 CAS + volatile 和 native 方法保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升

CAS 补充了 volatile 的原子性，采用乐观锁的思想保证并发安全。主要区别就是 CAS 会自旋，当操作失败的时候，会重新执行操作

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

7.5.2 源码分析

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

Atomiclnteger 里面的 value 原始值为 3，即主内存中 Atomiclnteger 的 value 为 3，根据 JMM 模型，线程 A 和线程 B 各自持有一  份值为 3 的 value 的副本分别到各自的工作内存
线程 A 通过getntVolatile(var1, var2) 拿到 value 值 3，这时线程 A 被挂起
线程 B 也通过getlntVolatile(var1, var2)方法获取到 value 值 3，此时刚好线程 B 没有被挂起并执行 compareAndswaplnt 方法比较内存值也为 3，成功修改内存值为 4，线程 B 打完收工，一切OK
这时线程 A 恢复，执行 compareAndswaplnt 方法比较，发现自己手里的值数字 3 和主内存的值数字 4 不一致，说明该值已经被其它线程抢先一步修改过了，那 A 线程本次修改失败，只能重新读取重新来一遍了
线程 A 重新获取 value 值，因为变量 value 被 volatile 修饰，所以其它线程对它的修改，线程 A 总是能够看到，线程 A 继续执行compareAndSwaplnt 进行比较替换，直到成功

7.5.3 底层汇编

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

总结：

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

7.6 原子引用

public class AtomicReferenceDemo {

    /**
     * 运行结果：
     * true	User(userName=l4, age=28)
     * false	User(userName=l4, age=28)
     */
    public static void main(String[] args) {
        AtomicReference<User> atomicReference = new AtomicReference<>();
        User z3 = new User("z3", 22);
        User l4 = new User("l4", 28);

        atomicReference.set(z3);

        System.out.println(atomicReference.compareAndSet(z3, l4) + "\t" + atomicReference.get());
        System.out.println(atomicReference.compareAndSet(z3, l4) + "\t" + atomicReference.get());

    }

}

@AllArgsConstructor
@ToString
@Getter
class User {

    private String userName;
    private int age;

}

7.7 CAS 与自旋锁，借鉴 CAS 思想

7.7.1 是什么？

CAS 是实现自旋锁的基础，CAS 利用 CPU 指令保证了操作的原子性，以达到锁的效果，至于自旋锁 -----> 字面意思让自己旋转。是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样子的好处是减少线程上下文切换的消耗，缺点是循环会消耗 CPU

7.7.2 自己实现一个自旋锁 spinLockDemo

题目：实现一个自旋锁，借鉴 CAS 思想

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

public class SpinLockDemo {

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

    /**
     * 题目：实现一个自旋锁，复习 CAS 思想
     * 自旋锁好处：循环比较获取没有类似 wait 的阻塞
     * 通过 CAS 操作完成自旋锁，A 线程先进来调用 lock 方法自己持有锁 5 秒，B 线程进来后发现
     * 当前锁被 A 线程持有，所以只能通过自旋锁等待，直到 A 线程释放锁后 B 线程获取锁
     *
     * 运行结果：
     * A ------come in
     * B ------come in
     * A ------task over，unLock
     * B ------task over，unLock
     */
    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(() -> {
            spinLockDemo.lock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            }
            spinLockDemo.unlock();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            spinLockDemo.lock();
            spinLockDemo.unlock();
        }, "B").start();

    }

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

        }
    }

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

}

7.8 CAS 缺点

7.8.1 循环时间长开销很大

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 方法有一个 do while
如果 CAS 失败，会一直进行尝试，如果 CAS 长时间一直不成功，可能会给 CPU 带来很大开销

7.8.2 引出来 ABA 问题？

ABA 问题怎么产生的？

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

版本号时间戳原子引用

AtomicStampedReference 带戳记流水的简单演示（单线程）

public class AtomicStampedDemo {

    /**
     * 运行结果：
     * Book(id=1, bookName=javaBook)	1
     * true	Book(id=2, bookName=mysqlBook)	2
     * true	Book(id=1, bookName=javaBook)	3
     */
    public static void main(String[] args) {
        Book javaBook = new Book(1, "javaBook");
        AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<>(javaBook, 1);

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

        Book mysqlBook = new Book(2, "mysqlBook");
        boolean 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());
    }

}

@AllArgsConstructor
@NoArgsConstructor
@Data
class Book {

    private int id;
    private String bookName;

}

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

产生 ABA 问题

public class ABADemo {

    private static AtomicInteger atomicInteger = new AtomicInteger(100);

    /**
     * 运行结果：
     * true	2022
     */
    public static void main(String[] args) {
        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, 2022) + "\t" + atomicInteger.get());
        }, "t2").start();

    }

}

解决方式

public class ABADemo {

    private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);

    /**
     * 运行结果：
     * t3	第1次版本号为1
     * t4	第1次版本号为1
     * t3	第2次版本号为2
     * t3	第3次版本号为3
     * false	100	3
     */
    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号为" + 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第1次版本号为" + stamp);
            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();

    }


}

一句话：比较加版本号一起上

posted @ 2026-04-15 12:56 清风含薰阅读(4) 评论(0) 收藏举报

刷新页面返回顶部

applework