掌握 Java CAS（Compare-And-Swap）操作：理解无锁编程思想，实现高效的并发更新。

掌握 Java CAS（Compare-And-Swap）操作：理解无锁编程思想，实现高效的并发更新 (专家讲座版)

各位观众，各位小伙伴们，大家好！我是你们的老朋友，人称“代码界的百灵鸟”的阿布。今天，咱们要聊点硬核的，但保证让大家听得津津有味，甚至想立马拿起键盘敲两行代码试试身手。

今天的主题是：Java CAS（Compare-And-Swap）操作，这玩意儿听起来高大上，其实就是个“瞒天过海”的小技巧，能让你在并发编程的世界里，像一只优雅的黑天鹅，避开拥挤的锁，自由自在地展翅翱翔！

一、并发世界里的锁：一道不得不翻越的山？

在开始之前，咱们先来想象一个场景：你和你的小伙伴同时想往同一个账户里存钱。如果没有协调机制，那账户里的钱数岂不是要乱套？

传统的解决方案就是“锁”。就像你家大门上的那把锁一样，谁想进屋（访问共享资源），就得先拿到钥匙（获得锁），用完之后再把钥匙还回去。这保证了同一时刻只有一个线程能访问共享资源，避免了数据混乱。

但是，锁就像一座大山，挡住了并发的道路。线程在等待锁的时候，会进入阻塞状态，这可是非常耗费资源的！想象一下，你排队去买演唱会门票，结果前面的人一直磨磨蹭蹭，你是不是恨不得把他踹下去？线程也是一样，被阻塞了，效率就下降了。

而且，锁还会带来一些复杂的问题，比如死锁（Deadlock）。两个线程互相持有对方需要的锁，谁也释放不了，就像两辆车头尾相撞，谁也动不了，场面一度十分尴尬 😓。

二、CAS：无锁编程的“乾坤大挪移”

既然锁有这么多缺点，那有没有一种不用锁也能保证线程安全的方法呢？答案就是：CAS (Compare-And-Swap)。

CAS就像武侠小说里的“乾坤大挪移”，它不使用锁，而是通过一种乐观的方式来更新共享变量。它的核心思想是：“我猜现在的值是A，如果是的话，我就把它更新为B；如果不是，说明别人已经改过了，我就重新尝试。”

咱们用一个生动的例子来解释一下：

假设有一个共享变量 count，初始值为 10。有两个线程 A 和 B 想要同时对 count 进行加 1 操作。

线程 A：
1. 读取 count 的值，发现是 10。
2. 它乐观地认为，在它计算 10 + 1 = 11 的这段时间内，count 的值没有被其他线程修改。
3. 它向 CPU 发出指令：“如果 count 的值现在还是 10，我就把它更新为 11。”
4. 如果 CPU 发现 count 的值确实是 10，就成功地将它更新为 11。
5. 如果 CPU 发现 count 的值已经被其他线程修改了（比如变成了 12），就告诉线程 A：“更新失败！” 线程A重新读取count的值（12），重新计算（12+1 = 13），重新尝试更新…
线程 B：
线程 B 的过程和线程 A 类似，只不过它可能会在线程 A 之前或之后尝试更新。

这种“先比较，再交换”的操作是由 CPU 提供的原子指令保证的，这意味着 CAS 操作在执行过程中不会被中断，要么成功，要么失败，不存在中间状态。

三、CAS 的三要素：

CAS 操作需要三个关键要素：

V (Variable)： 要更新的变量。也就是共享变量，比如上面的 count。
E (Expected)： 期望值。也就是你认为变量现在应该是什么值。
N (New)： 新值。也就是你想要把变量更新成什么值。

这三个要素就像一个精密的齿轮，缺一不可。

四、Java 中的 CAS 实现：AtomicInteger 类

在 Java 中，java.util.concurrent.atomic 包下提供了一系列的原子类，比如 AtomicInteger、AtomicLong、AtomicReference 等，它们都使用了 CAS 操作来实现无锁的线程安全。

咱们以 AtomicInteger 为例，看看它是如何使用 CAS 的：

import java.util.concurrent.atomic.AtomicInteger;

public class CasExample {

    private static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {

        // 创建 10 个线程，每个线程对 count 进行 1000 次 increment 操作
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    count.incrementAndGet(); // 使用 CAS 操作进行原子性的加 1
                }
            }).start();
        }

        // 等待所有线程执行完毕
        Thread.sleep(2000);

        System.out.println("最终的 count 值为：" + count.get()); // 最终的 count 值应该是 10000
    }
}

在这个例子中，AtomicInteger 类的 incrementAndGet() 方法就是使用 CAS 操作来实现原子性的加 1。它会不断地尝试更新 count 的值，直到更新成功为止。

AtomicInteger 内部的 compareAndSet() 方法，就是CAS操作的核心：

public final boolean compareAndSet(int expectedValue, int newValue) {
    return unsafe.compareAndSwapInt(this, valueOffset, expectedValue, newValue);
}

这里的unsafe 是一个Unsafe 类的实例，它提供了访问底层硬件的能力。compareAndSwapInt() 方法是 CPU 提供的原子指令，它会比较 valueOffset 处的值是否等于 expectedValue，如果相等，就把它更新为 newValue，并返回 true；否则，返回 false。

五、CAS 的优缺点：

任何技术都有它的两面性，CAS 也不例外。

优点：

无锁： 避免了锁带来的开销，提高了并发性能。
轻量级： 相对于锁来说，CAS 操作更加轻量级，不会导致线程阻塞。
适用于竞争不激烈的场景： 在竞争不激烈的场景下，CAS 的成功率很高，性能提升非常明显。

缺点：

ABA 问题： 这是 CAS 最著名的缺点。假设一个变量的值一开始是 A，被线程修改成了 B，然后又被改回了 A。对于 CAS 来说，它会认为这个变量的值没有发生变化，但实际上，它已经被修改过了。就像你女朋友/男朋友换了个发型，又换回了原来的发型，你以为她/他没变，但其实她/他的内心已经经历了沧海桑田 😅。
自旋开销： 如果 CAS 操作一直失败，线程会不断地自旋（不断地尝试），这会消耗 CPU 资源。
只能保证单个变量的原子性： CAS 只能保证对单个变量的原子性操作，如果需要保证多个变量的原子性，就需要使用锁或者其他并发工具。

六、如何解决 ABA 问题？

解决 ABA 问题的方法通常是引入版本号（Version）。每次变量被修改时，版本号都会增加。这样，即使变量的值又变回了 A，但版本号已经不同了，CAS 就会检测到这个变化。

Java 中提供了 AtomicStampedReference 类来解决 ABA 问题。咱们看一个例子：

import java.util.concurrent.atomic.AtomicStampedReference;

public class AbaExample {

    private static AtomicStampedReference<Integer> count = new AtomicStampedReference<>(100, 0);

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            int stamp = count.getStamp(); // 获取当前的版本号
            System.out.println("线程 1：当前版本号为：" + stamp);

            try {
                Thread.sleep(1000); // 模拟线程 1 的一些操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            boolean success = count.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println("线程 1：是否成功将 count 从 100 更新为 101？" + success);
        });

        Thread t2 = new Thread(() -> {
            int stamp = count.getStamp(); // 获取当前的版本号
            System.out.println("线程 2：当前版本号为：" + stamp);

            // 模拟线程 2 将 count 从 100 改为 101，再改回 100
            count.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println("线程 2：成功将 count 从 100 更新为 101");
            stamp = count.getStamp();
            count.compareAndSet(101, 100, stamp, stamp + 1);
            System.out.println("线程 2：成功将 count 从 101 更新为 100");
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("最终的 count 值为：" + count.getReference());
        System.out.println("最终的版本号为：" + count.getStamp());
    }
}

在这个例子中，AtomicStampedReference 使用了一个版本号来跟踪变量的变化。即使线程 2 将 count 的值从 100 改为 101，再改回 100，线程 1 在尝试更新 count 的时候，会发现版本号已经发生了变化，从而避免了 ABA 问题。

七、CAS 的应用场景：

CAS 在并发编程中有着广泛的应用，比如：

原子计数器： AtomicInteger、AtomicLong 等原子类，可以用来实现原子性的计数器。
并发队列： ConcurrentLinkedQueue 等并发队列，可以使用 CAS 来实现无锁的入队和出队操作。
乐观锁： CAS 可以用来实现乐观锁，提高并发性能。
无锁数据结构： CAS 可以用来构建无锁的数据结构，比如无锁栈、无锁链表等。

八、CAS 的总结：

CAS 是一种重要的并发编程技术，它通过一种乐观的方式来更新共享变量，避免了锁带来的开销，提高了并发性能。

咱们用一张表格来总结一下 CAS 的关键点：

特性	说明
原理	比较并交换，基于 CPU 提供的原子指令实现。
优点	无锁，轻量级，适用于竞争不激烈的场景。
缺点	ABA 问题，自旋开销，只能保证单个变量的原子性。
应用场景	原子计数器，并发队列，乐观锁，无锁数据结构。
解决 ABA 问题	使用版本号，如 `AtomicStampedReference`。

九、最后的絮叨：

CAS 就像一把双刃剑，用得好，能让你在并发编程的世界里所向披靡；用不好，可能会让你陷入 ABA 问题的泥潭。

所以，在使用 CAS 的时候，一定要充分理解它的原理和优缺点，选择合适的场景，并采取必要的措施来避免 ABA 问题。

记住，并发编程是一门艺术，需要不断地学习和实践才能掌握。希望今天的讲解能给大家带来一些启发，让大家在并发编程的道路上越走越远，越走越宽广！

好了，今天的分享就到这里，感谢大家的收听，咱们下次再见！ 👋

掌握 Java CAS（Compare-And-Swap）操作：理解无锁编程思想，实现高效的并发更新 (专家讲座版)

发表回复 取消回复

发表回复取消回复