当前位置： 首页>编程语言>正文

深入理解CAS（乐观锁）

编程语言2024-11-29 19:57:56

深入理解CAS（乐观锁）

java使用CAS之前

在JDK5之前Java语言是靠synchronized关键字保证同步的，这会导致有锁，锁机制存在以下问题：

  • 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题
  • 一个线程持有锁会导致其他所有需要此锁的线程挂起
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能风险

volatile是不错的机制，但是volatile不能保证原子性。因此对于同步最终还是要回到锁机制上来。

独占锁是一个悲观锁，synchronized就是一种独占锁，会导致其他所有需要锁的线程挂起，等待持有锁的线程释放锁。而另一种更加有效的锁就是乐观锁，CAS就是一种乐观锁

什么是CAS

在java语言之前，并发就已经广泛存在并在服务器领域得到了大量的应用。所以硬件厂商老早就在芯片中加入了大量支持并发操作的原语（原语是由若干条指令组成的，用于完成一定功能的一个过程，具有不可分割性，即原语的执行必须是连续的，在执行过程中不允许被中断），从而在硬件层面提升效率。在intel的CPU中，使用cmpxchg指令。

在java发展初期，java语言是不能够利用硬件提供的这些便利来提升系统性能的。而随着java不断的发展，java本地方法（JNI）的出现，为java程序越过jvm直接调用本地方法提供了一种便捷的方式，因而java在并发的手段上也多了起来。而在Doug Lea提供的concurrent包中，CAS理论是他实现整个java并发包的基石。

CAS操作包含三个操作数—— 内存位置的值（V）、预期原值（A）和新值（B）。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值。CAS有效地说明了“我认为位置V应该包含值A；如果包含该值，则将B放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。”

CAS是一种有名的无锁算法。无锁编程，即不适用锁的情况下实现多线程之间的变量同步，也就是在没有现成被阻塞的情况下实现变量的同步。

总结如下：

  • CAS（Compare And Swap）比较并替换，是线程并发运行时用到的一种技术
  • CAS是原子操作，保证并发安全，而不能保证并发同步
  • CAS是CPU的一个指令（需要JNI调用Native方法，才能调用CPU的指令）
  • CAS是非阻塞的、轻量级的乐观锁

为什么说CAS是乐观锁

乐观锁，严格来说并不是锁，通过原子性来保证数据的同步，比如说数据库的乐观锁，通过版本控制来实现，所以CAS不会保证线程同步。乐观的认为在数据更新期间没有其他线程影响。

CAS原理

CAS（Compare And Swap）就是将内存值更新为需要的值，但是有个条件，内存值必须与期望值相同。举个例子，内存值V、期望值A、更新值B，当V == A的时候将V更新为B。

CAS应用

由于CAS是CPU指令，我们只能通过JNI与操作系统交互，关于CAS的方法都在sun.misc包下Unsafe的类里，java.util.concurrent.atomic包下的原子类等通过CAS来实现原子操作。

使用乐观锁还是悲观锁

从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的吞吐量。但如果是多写的情况，一般会经常发生冲突，这就会导致CAS算法会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

CAS指令和具体源代码

原子类例如AtomicInteger里的方法都很简单，我们看一下getAndIncrement方法：

//该方法功能是Interger类型加1
public final int getAndIncrement() {
        //主要看这个getAndAddInt方法
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

//var1 是this指针
//var2 是地址偏移量
//var4 是自增的数值，是自增1还是自增N
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            //获取内存值，这是内存值已经是旧的，假设我们称作期望值E
            var5 = this.getIntVolatile(var1, var2);
            //compareAndSwapInt方法是重点，
            //var5是期望值，var5 + var4是要更新的值
            //这个操作就是调用CAS的JNI,每个线程将自己内存里的内存值M
            //与var5期望值E作比较，如果相同将内存值M更新为var5 + var4,否则做自旋操作
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

解释一下getAndAddInt方法的流程：

假设有一下情景：

  1. A、B两个线程
  2. jvm主内存的值1，A、B工作内存的值为1（工作内存会拷贝一份主内存的值）
  3. 当前期望值为1，做加1操作
  4. 此时var5 = 1，var4 = 1；
    1. A线程将var5与工作内存值M比较，比较var5是否等于1
    2. 如果相同则将工作内存值修改为var5 + var4 即修改为2并同步到驻村，此时this + valueOffset指针里，示例变量value的值就是2，结束循环
    3. 如果不相同，则是B线程修改了主内存的值，说明B线程已经先于A线程做了加1操作，A线程没有更新成功需要继续循环，注意此时var5更新为新的内存值，假设当前的内存值是2，那么此时var5 = 2，var + var4 = 3，重复上述步骤直到成功（自旋），成功之后，内存地址中的值就改变为3

CAS优缺点

  • 优点

非阻塞的轻量级的乐观锁，通过CPU指令实现，在资源竞争不激烈的情况下性能高，相比synchronized重量锁，synchronized会进行比较复杂的加锁、解锁和唤醒操作。

  • 缺点
  1. ABA问题： 线程C、D；线程D将A修改为B后又修改为A，此时C线程以为A没有改变过，java的原子类AtomicStampedReference，通过控制变量值的版本号来保证CAS的正确性。具体解决思路就是在变量前追加上版本号，每次变量更新的时候把版本号加一，那么A - B - A就会变成1A - 2B - 3A。
  1. 自旋时间过长，消耗CPU资源，如果资源竞争激烈，多线程自旋长时间消耗资源

https://www.xamrdz.com/lan/53d2016570.html

相关文章：