java EE 初阶 — CAS 的介绍

矫情吗；* 2023-10-03 23:22 41阅读 0赞

#### 文章目录 ####

*  CAS
 *   *  1. 什么是 CAS
     *  2. CAS 是怎么实现的
     *  3. CAS 有哪些应用
     *   *  3.1 实现原子类
         *  3.2 实现自旋锁
     *  4. CAS 的 ABA 问题
     *   *  4.1 什么是 ABA 问题
         *  4.2 ABA 问题引来的 BUG
         *  4.3 解决方案
     *  5. 相关面试题

## CAS ##

### 1. 什么是 CAS ###

**CAS**：全称 Compare and swap，字面意思：**”比较并交换“**。

一个 CAS 涉及到以下操作：

我们假设内存中的 **原数据V**，**旧的预期值A**，需要修改的**新值B**。

1.  比较 A 与 V 是否相等。（比较）
2.  如果比较相等，将 B 写入 V。（交换）
3.  返回操作是否成功。

举个例子。  
  
![ca712f7791254b2ab5abd27075a7116d.png_pic_center][]

### 2. CAS 是怎么实现的 ###

此处最特别的地方，上述这个 CAS 的过程并非是通过一段代码实现的，  
而是通过一条 CPU 指令完成的。

因为 CAS 操作是原子的，所以就可以在一定程度上回避线程安全问题。

解决线程安全问题，除了加锁之外，又有了一个新的方向了。  
  
CAS 可以理解为是 CPU 给咱们提供的一个特殊指令，通过这个指令，就可以一定程度上处理线程安全问题。  
  
观察下面一段伪代码（只是辅助理解CAS 的工作流程）

boolean CAS(address, expectValue, swapValue) {
        
        if (&address == expectedValue) {
        
            &address = swapValue;
            return true;
        }
        return false;
    }

**address** 就相当于是上面例子的 V，**expectValue** 相当于是 A  
**swapValue** 相当于是 B。

### 3. CAS 有哪些应用 ###

#### 3.1 实现原子类 ####

java 标准库中提供了 **java.util.concurrent.atomic** 包，里面的类都是基于这种方式来实现的。

典型的就是 **AtomicInteger** 类。  
其中：  
**getAndIncrement** 相当于 i++ 操作，  
**incrementAndGet** 相当于是 ++i 操作。  
**getAndDecrement** 相当于是 i-- 操作，  
**decrementAndGet** 相当于是 --i 操作。

package thread;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class ThreadDemo8 {
        
    
        public static void main(String[] args) throws InterruptedException{
        
            // 这些原子类，就是基于 CAS 实现了自增，自减操作，此时进行这类操作不加锁，也是线程安全的
            AtomicInteger count = new AtomicInteger(0);
    
            // 使用原子类来解决线程安全问题
            Thread t1 = new Thread(() -> {
        
                for (int i = 0; i < 5000; i++) {
        
                    count.getAndIncrement();// 相当于是 count++
                }
            });
    
            Thread t2 = new Thread(() -> {
        
                for (int i = 0; i < 5000; i++) {
        
                    count.getAndIncrement();// 相当于是 count++
                }
            });
    
            t1.start();
            t2.start();
            t1.join();
            t2.join();
    
            System.out.println(count.get());
        }
    }

因为进行这类操作不加锁是，也是线程安全的，所以代码会输出 10000。  
  
![73abe64bfdb040848f037d7c2943a6cf.png_pic_center][]  
  
针对上面 **count++** 操作的伪代码实现：

class AtomicInteger {
        
        private int value;
        
        public int getAndIncrement() {
        
            int oldValue = value;
            while ( CAS(value, oldValue, oldValue+1) != true) {
        
                oldValue = value;
            }
            return oldValue;
        }
    }

代码分析  
  
箭头从上到下代表执行的顺序。  
  
![fb2a328bb17541c0bee573c56a8b91dc.png_pic_center][]  
  
1、**t1** 先执行 load ，把 **value** 的值读到 **oldvalue** 中。  
  
读取后  
  
![0baf55608f0c46f8a5603446b4c03267.png_pic_center][]  
  
  
2、**执行 t2 的 load 操作，把 value 的值 读到 oldvalue 中**  
  
执行后  
  
![c38a1c05e86040949eab8ca90831ee7e.png_pic_center][]  
  
  
3、**t2 执行 CAS 操作比较 oldvalue 和 value 的值是否相等**

此时 value 与 oldvalue 的值相等，就将 **oldValue+1** 的值读给 value。  
  
读取后  
  
![a68103c29f134d968670ff2ec046219c.png_pic_center][]  
  
  
4、**t1 执行 CAS 操作比较 oldvalue 和 value 的值是否相等**

此时 value 与 oldvalue 的值不相等，CAS 返回 false，并且不进行任何交换。

while ( CAS(value, oldValue, oldValue+1) != true) {
        
          oldValue = value;
      }

针对于上述的代码，CAS 返回 false 后，进入 while 循环，将 value 的值 读给 oldvalue。

紧接着 t1 就要再接着执行一次 load 和 CAS。  
  
读取后。  
  
![d26a0e407b6d43a3be0b2a76d0da13c8.png_pic_center][]  
  
  
5、**t1 执行 CAS 操作比较 oldvalue 和 value 的值是否相等**

此时 value 与 oldvalue 的值相等，就将 **oldValue+1** 的值读给 value。  
  
读取后  
  
![67d30b1dc0a74bb185d2d1c5f00fd5ec.png_pic_center][]  
  
此时比较相等，CAS 返回 true ，循环就结束了。  
  
上面的伪代码要结合下面的图示来理解。

#### 3.2 实现自旋锁 ####

基于 CAS 实现更灵活的锁，获取到更多的控制权。  
  
自旋锁的伪代码：

public class SpinLock {
        
        private Thread owner = null;
        public void lock(){
        
            // 通过 CAS 看当前锁是否被某个线程持有.
            // 如果这个锁已经被别的线程持有, 那么就自旋等待.
            // 如果这个锁没有被别的线程持有, 那么就把 owner 设为当前尝试加锁的线程.
            while(!CAS(this.owner, null, Thread.currentThread())){
        
            }
        }
        public void unlock (){
        
            this.owner = null;
        }
    }

**this.owner, null** 监测当前的 owner 是否是 null ，如果是 null就进行交换，  
也就是把当前线程的引用赋值给 owner 。  
如果赋值成功，此时循环结束，加锁完成了。

如果当前锁已经被别的线程占用了，CAS 就会发现 this.owner 不是 null。  
CAS 就不会产生赋值，也同时返回 false ，循环继续执行，并且下次判定。

### 4. CAS 的 ABA 问题 ###

#### 4.1 什么是 ABA 问题 ####

CAS 在运行中的核心，检查 value 和 oldvalue 是否一致。  
如果一致就视为 value 中途没有被修改过，所以进行下一步操作是没有问题的。

这里指的一致，可能是没有改过，也可能改过之后又还原回来了。

比方说，把 value 的值设为 A 的话，CAS 判定 value 为 A 此时可能确实 value 始终是 A。  
也可能是 value 本来是 A ，被改成了 B 后又改回了 A 。  
  
举个例子。  
  
就像是买手机，我买到的这个手机，可能是翻新机，也可能是新机。  
不管是哪一种，我都无法区分。

#### 4.2 ABA 问题引来的 BUG ####

ABA 这个情况大部分情况下其实是不会对代码逻辑产生太大影响的。

但是不排除一些比较极端情况，也是可能造成影响的。  
  
下面举一个在实际开发环境中发生概率不大的例子  
  
假设当前滑稽老铁的账户余额 为 1000 ，滑稽准备去 500 。

当按下取款这一瞬间的时候，机器卡了一下，滑稽老铁忍不住就多按了几下。  
这是可能就会产生 bug ，可能就会触发重复扣款的操作。

考虑使用 CAS 的方式来扣款。  
  
![486ee112547543e38894e35220ccdcb6.png_pic_center][]  
  
t1 和 t2 都执行 load 操作，都读取到了 1000 这个值。  
紧接着 t1 执行 CAS 比较一下，看看此时的余额是不是 1000，如果是 1000 就扣 500。

当 t2 执行 CAS 操作的时候，滑稽的余额为 500 不等于 1000，此时扣款不成功。  
  
如果在执行果第一个 CAS 后，有人给滑稽转了 500 元，此时余额又变成了 1000。  
这就相当于，本来是 1000 变成 500 后 又变成了 1000 ，这就是一个ABA 问题。  
  
![c649a84ffab747f5bbec8fd7982d50f5.png_pic_center][]  
  
此时的余额是 1000 ，就又扣款成功了，这里就出现 bug 了。

#### 4.3 解决方案 ####

针对当前的问题，采取的方案就是 **加一个版本号**

比方说，初始版本号是 1 ，每次修改版本号都加1，然后进行 CAS 的时候，不是以金额为准了，而是以版本号为准。

版本号真是增长的，不能降低。此时只要是版本号没变，就是一定没有发生改变。

### 5. 相关面试题 ###

1、**讲解下你自己理解的 CAS 机制**  
  
全称 Compare and swap，即 “比较并交换”。  
相当于通过一个原子的操作，同时完成 “读取内存，比较是否相等，修改内存” 这三个步骤。  
本质上需要 CPU 指令的支撑。

2、**ABA问题怎么解决**  
  
给要修改的数据引入版本号。在 CAS 比较数据当前值和旧值的同时，也要比较版本号是否符合预期。  
如果发现当前版本号和之前读到的版本号一致，就真正执行修改操作，并让版本号自增；如果发现当  
前版本号比之前读到的版本号大，就认为操作失败。

[ca712f7791254b2ab5abd27075a7116d.png_pic_center]: https://img-blog.csdnimg.cn/ca712f7791254b2ab5abd27075a7116d.png#pic_center
[73abe64bfdb040848f037d7c2943a6cf.png_pic_center]: https://img-blog.csdnimg.cn/73abe64bfdb040848f037d7c2943a6cf.png#pic_center
[fb2a328bb17541c0bee573c56a8b91dc.png_pic_center]: https://img-blog.csdnimg.cn/fb2a328bb17541c0bee573c56a8b91dc.png#pic_center
[0baf55608f0c46f8a5603446b4c03267.png_pic_center]: https://img-blog.csdnimg.cn/0baf55608f0c46f8a5603446b4c03267.png#pic_center
[c38a1c05e86040949eab8ca90831ee7e.png_pic_center]: https://img-blog.csdnimg.cn/c38a1c05e86040949eab8ca90831ee7e.png#pic_center
[a68103c29f134d968670ff2ec046219c.png_pic_center]: https://img-blog.csdnimg.cn/a68103c29f134d968670ff2ec046219c.png#pic_center
[d26a0e407b6d43a3be0b2a76d0da13c8.png_pic_center]: https://img-blog.csdnimg.cn/d26a0e407b6d43a3be0b2a76d0da13c8.png#pic_center
[67d30b1dc0a74bb185d2d1c5f00fd5ec.png_pic_center]: https://img-blog.csdnimg.cn/67d30b1dc0a74bb185d2d1c5f00fd5ec.png#pic_center
[486ee112547543e38894e35220ccdcb6.png_pic_center]: https://img-blog.csdnimg.cn/486ee112547543e38894e35220ccdcb6.png#pic_center
[c649a84ffab747f5bbec8fd7982d50f5.png_pic_center]: https://img-blog.csdnimg.cn/c649a84ffab747f5bbec8fd7982d50f5.png#pic_center