CAS和CAS中的ABA问题

最新推荐文章于 2024-07-24 17:27:32 发布

XY枫晨

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量110

点赞数 1

文章标签： jvm java 算法

本文链接：https://blog.csdn.net/qq_36935038/article/details/129276830

版权

什么是 CAS

CAS: 全称Compare and swap（比较并交换），它是原子的操作。

一个CAS涉及的操作：

1、比较内存和寄存器A的值是否相同

2、相同的话将内存和寄存器B的值进行交换【主要目的是将寄存器B的值赋值给内存】并且返回true

3、不同返回false

用一段“伪代码”来理解：

下面写的代码不是原子的, 真实的 CAS 是一个原子的硬件指令完成的. 这个伪代码只是辅助理解CAS 的工作流程.

//address 内存  expectValue寄存器A   swapValue寄存器B
boolean CAS(address, expectValue, swapValue) {
 if (&address == expectedValue) {
     //只关心将寄存器B的值赋值给内存
   &address = swapValue;
        return true;
   }
    return false;
}

CAS是线程安全的并且效率很高

当多个线程同时对某个资源进行CAS操作，只能有一个线程操作成功，但是并不会阻塞其他线程,其他线程只会收到操作失败的信号。

【CAS是实现乐观锁的一种方式】

CAS的应用

1、实现原子类

前面我们分析过cout++不是原子的操作，会导致线程不安全，要想安全，就得加锁，加锁的话程序的性能就会降低，我们可以基于CAS操作来实现“原子“的++操作，而且还能保证线程安全和高效。

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

典型的就是 AtomicInteger 类. 其中的 getAndIncrement 相当于 i++ 操作.

public static void main(String[] args) throws InterruptedException {
        AtomicInteger count = new AtomicInteger(0);
        count.getAndIncrement();
        System.out.println(count.getAndIncrement());
    }

来看看AtomicInteger 类伪代码来理解一下：

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

解释：

1、先LOAD读取寄存器A读取内存中的值

2、CAS：如果寄存器A(oldValue)的值和内存（value）的值相同，就把寄存器B（oldValue+1）的值赋值给内存（value）并且返回true，结束while循环

3、如果返回的是CAS的返回值为false，寄存器A重新读取内存的值，再次进行第二步

4、返回的是还没有增加的值，类似于i++。

注意，上面的代码是伪代码，只能让我们理解，伪代码实际上仍然是线程不安全的，实际内部是怎么样的这是JVM里面的东西我们不知道。

2、实现自旋锁

纯用户态的轻量级锁.

基于 CAS 实现更灵活的锁, 获取到更多的控制权.

public class SpinLock {
    //记录当前锁被哪个线程获取 null表示锁无人获取
    private Thread owner = null;
    public void lock(){
        // 通过 CAS 看当前锁是否被某个线程持有. 
        // 如果这个锁已经被别的线程持有, 那么就自旋等待. 
        // 如果这个锁没有被别的线程持有, 那么就把 owner 设为当前尝试加锁的线程. 
        while(CAS(this.owner, null, Thread.currentThread()) != true!){
       }
   }
    //用完了锁那就释放掉
    public void unlock (){
        this.owner = null;
   }
}

!CAS(this.owner, null, Thread.currentThread())

CAS去看owner中是否解锁的状态【比较owner和null是否相同】,如果没有,赶集加锁,把当前进程赋值给owner意思相当于占用锁,告诉别人这个锁是我这个线程的了。

如果owner不为null，则CAS不交换，返回false，再次进入循环，进行判断。

CAS中的ABA问题

什么是ABA问题

在CAS进行到比较操作的时候，如果发现寄存器A中的值和内存中值M相同，此时，我们无法确定M是否是始终没发生过变化的M，还是说M经过了一些计算之后又变回了原来的M。

举例：小明看上二手商贩的一台某品牌手机，小明说如果过几天回来还在，就买下它，商贩嘴上说可以，过几天小明回来了看到还在就买了回来，但是期间小明不知道手机还是不是之前看到的那台，（假设小明就喜欢之前那台，一模一样的他都不同意）此期间手机有没有卖出去过换上另外一台二手手机小明是不知道的。

解决ABA问题

我们可以另外增加一个内存，保存M的“修改次数”（版本号）而且是只增不减的后者是“上次修改时间”通过这个办法就可以解决ABA问题。

例如：设当前余额为 100. 引入一个版本号 version, 初始值为 1. 并且我们规定内存的值和寄存器A的值相同并且 “提交版本必须大于记录当前版本才能执行更新余额”

线程 A 此时准备将其读出（ version=1, 线程1寄存器A的balance=100 ），线程 B 也读入此信息（ version=1, 线程2寄存器A的balance=100 ）.

线程 A 操作的过程中并从其帐户余额中扣除 50（ 100-50）线程1寄存器B的Bbalance=50，线程 B 从其帐户余额中扣除 20 （ 100-20 ）线程2寄存器B的Bbalance=80；

线程 A 完成修改工作，将数据版本号加1（ version=2 ），连同帐户扣除后余额（ balance=50 ），写回到内存中;

4、此时有线程3读取了内存并增加了20，让balance = 100

5、线程 B 完成了操作，也将版本号加1（ version=2 ）试图向内存中提交数据（ balance=80 ），但此时比对版本发现，操作员 B 提交的数据版本号为 2 ，数据库记录的当前版本也为 2 ，不满足 “提交版本必须大于记录当前版本才能执行更新“ 的乐观锁策略。就认为这次操作失败.