【多线程】CAS机制

原创已于 2025-04-05 18:17:45 修改 · 1.1k 阅读

29 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #java-ee

于 2025-04-05 18:16:40 首次发布

Java多线程编程专栏收录该内容

11 篇文章

订阅专栏

一. CAS的概念

CAS（Compare And Swap）机制是一种无锁的并发控制技术，用于多线程并发编程时数据在无锁的情况下保证线程安全安全运行。

CAS是一个特殊的cpu指令，通过比较和交换的操作实现特定的功能
整个比较和交换过程必须在一个不可中断的指令中完成（单个cpu指令，本身具有原子性）

下面详细介绍这条特殊指令的原理

二. CAS的原理

CAS机制的实现取决于3个核心操作数：内存中的值A、寄存器中的值B、寄存器中的新值C。

        boolean CAS(A,B,C) {
            if (&A == B) {
                &A = C;
                return true;
            }
            return false;
        }

这是一段伪代码，用于表示CAS实现的逻辑

比较内存中的值A和寄存器中的值B是否相等，如果相等，将寄存器中的新值C和内存中的值A进行交换，并返回true
如果不相等，什么也不做，返回false

画图过程演示：

判断发现A和B的值相等，故交换A和C的值

注意：这里的交换可以理解为赋值，因为寄存器C中的数值，使用后会被清空

这里只是演示实现的步骤和机制，这些操作都是通过一条指令实现的（本身就具有原子性）

我们会发现，这一系列的操作，不会出现线程安全问题（原子性），以前的线程安全问题，都是通过通过加锁和解锁的步骤来解决，但是性能会降低，如果可以合理的使用CAS机制（不涉及加锁和解锁，也就不会涉及阻塞），这样效率会大大提高，这样的操作叫做无锁编程

三.标准库中的CAS

CAS本身是cpu指令，操作系统对其进行了封装，JVM又对操作系统提供的API又进行了一次封装，放在了Unsafe包下
Java标准库中，又对CAS的实现进行了封装，提供了一些原子类，让我们可以直接使用，隐藏底层 Unsafe 的复杂性。

Java标准库中的CAS实现主要通过 java.util.concurrent.atomic 包下的原子类完成。

四. CAS的应用

（1）原子类的使用

AtomicInteger 类（原子类）

常用方法

getAndIncrement 方法，自增操作，类似于 i++。
getAndDecrement 方法，自减操作，类似于 i--。

案例：在不使用锁的情况下实现两个线程的自增，并返回正确的值

public class Demo1 {
    //public static int count = 0;
    public static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           for (int i = 0; i < 50000; i++){
               count.getAndIncrement();
           }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count.getAndIncrement();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count = " + count);
    }
}

其中的CAS实现的过程，通过伪代码来展示
class AtomicInteger {
    private int value;
    
    public int getAndIncrement() {
        int oldValue = value;
        while ( CAS(value, oldValue, oldValue+1) != true) {
            oldValue = value;
       }
        return oldValue;
   }
}
这样的实现过程，即使在两个进程同时执行的情况下，也不会出现线程安全的问题
在每次的赋值前提下，会有一步比较的过程，如果不是对的值，那么就不会进行交换（赋值）

（2）自旋锁的实现

自旋锁伪代码：

public class Lock {
    private Thread owner = null;
    
    public void lock(){
        while(!CAS(this.owner, null, Thread.currentThread())){

       }
   }
 }

如果ower 为null，CAS返回true，说明资源没有被别的线程持有，那么跳出循环
如果ower不为null，CAS返回false，说明资源被别的线程持有，那么会继续循环（自旋）

通过这样的’忙等‘来实现等待的效果，缺点是会消耗掉很多的cpu资源

五. CAS的ABA问题

CAS无法区分数值有没有在变化的途中被修改过

数值从开始到结束一直都是A，还是从A=>B=>A（中间发生了变化）

这种情况类似于 "翻新机"，外表看上去和新的一样，但是内部的组件可能发生了更换

造成ABA问题的本质原因：线程执行的过程中，被其他线程穿插进来

举例说明：

有一个单链表 A->B->C，其中A为头节点
线程1：如果头节点为A，则执行删除头节点操作
线程2：执行两次删除头节点操作，再插入节点A

（1）线程2没有穿插进来：

（2）线程2穿插进来：

如果再执行线程1操作的途中，线程2穿插进来，导致线程1没有发觉，可能导致返回后的数据有误