CAS原理

羅煞

于 2021-04-26 16:30:59 发布

阅读量146

点赞数

分类专栏： java多线程并发、锁文章标签： java

本文链接：https://blog.csdn.net/qq_25502749/article/details/116160468

版权

java多线程并发、锁专栏收录该内容

3 篇文章 0 订阅

订阅专栏

CAS（比较与交换，Compare and swap）是一种有名的无锁算法，它是乐观锁的一种实现方式。所以在进行CAS原理分析的时候，我们先来了解什么是乐观锁，什么是悲观锁~

乐观锁与悲观锁

乐观锁和悲观锁是在数据库中引入的名词，但是在我们Java的JUC里面的锁也引入类似的思想！我们来看看两种锁的概念

悲观锁

悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改，所有在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。我们的传统数据库就会用到这种排它锁的机制，比如行锁，表锁等，读锁，写锁等，都是在操作之前上锁，操作结束提交事务之后释放锁！在Java中像Synchronized同步术语，ReentrantLock等也是悲观锁！而像volatile关键字虽然是synchronized关键字的轻量级实现，但是其无法保证原子性，所以一般也要搭配锁使用。

乐观锁

乐观锁是相对悲观锁来说，它认为数据在一般情况下不会造成冲突，别人不会去修改，所以在访问记录前不会加排它锁。但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号，时间戳来等记录。因为不加锁，所以乐观锁在多读的情况下，可以极大的提升我们的吞吐量。在我们的数据库中提供了类似write_condition机制，在Java中JUC下的原子变量类也是使用了乐观锁的一种实现方式CAS，也就是我们下面即将介绍的！

CAS（Compare And Swap）原理解析

Java中，锁在并发处理中占据了一席之地，但是使用锁有一个不好的地方，就是当一个线程没有获取到锁时会被阻塞挂起，这会导致线程上下文的切换和重新调度开销。Java提供了非阻塞的volatile关键字来解决共享变量的可见性问题，这在一定程度上弥补了锁带来的开销问题，但是volatile只能保证共享变量的可见性，不能解决读改一写等的原子性问题。

CAS就是是JDK提供的非阻塞原子性操作，通过硬件保证了比较-更新操作的原子性。它的主要原理如下：

CAS有三个操作数

内存值v
旧的预期值A
要修改的新值B

当多个线程尝试使用CAS同时更新一个变量的时候，只有一个能够更新成功。那就是当我们的内存值V和旧的预期值A相等的情况下，才能将内存值V修改成B！然后失败的线程不会挂起，而是被告知失败，可以继续尝试（自旋）或者什么都不做！

尝试重试

我们可以假设有两个线程，一个线程1，一个线程2,同时对我们的内存值进行自增！我们的内存值刚开始是0，旧的预期值也是0。

这个时候线程1进来了，由于我们的内存值和旧的预期值相等，所以更新我们的内存值为要修改的新值1
当线程1结束之后，线程2进来了，要对我们的内存值进行修改。但是发现我们的内存A（此时为1）和我们的旧的预期值不相等（此时为0）不相等，所以不能将内存值更新为我们的预期值（预期值为2），所以只能进行将旧的预期值更新为内存值（此时旧的预期值 == 内存值），并告知下一次再试试！
当我们的线程2重试更新内存值，此时内存值（此时为1）与我们的旧的预期值（此时为1）相等，所以可以将我们的内存值更新为我们的预期值（此时为2）。

所以，哪怕没有加锁，我们也能实现线程安全。

什么都不做

同样的，我们举例有两个线程，一个线程1，一个线程2；我们两个线程都要对内存进行更新为10。

我们假设线程1先进来，此时内存值与我们的旧的预期值都为0，所以可以更新，将我们要修改的新值10赋值给了内存值，完成了更新
当线程1完成之后，线程2进来要对我们的内存值进行修改为10，但是发现内存值与旧的预期值不相同（此时一个为10，一个为0），所以只能将旧的预期值更新为内存值，同时被告知了下次不用重试了。（因为我们的目的是将内存值更新为10，显然我们的目的已经完成了）

原子变量类简单分析

我们在开头也提到了，在我们JUC下的原子变量类也是使用CAS来保证操作的原子性。而我们的具体原子变量类有以下这些：

我们以AtomicInteger为例，找一个其中自增的方法分析一下：

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

该方法主要为了自增，它调用了getAndAddInt方法。这个是方法是我们的Unsafe类下面

//var1 是this指针
//var2 是地址偏移量
//var4 是自增的数值，是自增1还是自增N   
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            //获取我们的的期望值赋值给var5
            var5 = this.getIntVolatile(var1, var2);
            //调用了Unsafe下面的另一个方法，是一个native方法
            //如果期望值var5与内存值var2相等的话，更新内存值为var5+var4，否则更新期望值为期望值为内存值
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

compareAndSwapInt方法是我们的调用native方法

// 第一和第二个参数代表对象的实例以及地址，第三个参数代表期望值，第四个参数代表更新值
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

它是由我们的底层c代码调用汇编使用的，最后生成出一条CPU指令cmpxchg，完成操作。这也就为啥CAS是原子性的，因为它是一条CPU指令，不会被打断。这个指令在我们早期的硬件厂商就在芯片大量使用了，比如intel。