面试必备系列JUC(3) -- CAS超详解

最新推荐文章于 2023-03-20 05:00:00 发布

猿侠令狐冲

最新推荐文章于 2023-03-20 05:00:00 发布

阅读量294

点赞数

分类专栏：面试 juc

本文链接：https://blog.csdn.net/u012736748/article/details/119803518

版权

面试同时被 2 个专栏收录

8 篇文章 4 订阅

订阅专栏

juc

8 篇文章 0 订阅

订阅专栏

面试必备系列JUC(3) -- CAS超详解

文章目录

前言
一、什么是CAS？
二、如何使用CAS
- 1.原子包atomic
- 2.CAS缺点
3.常考的面试题

前言

在JDK 早期版本中，Java是靠synchronized关键字保证线程间数据同步的，同样也带来了一系列问题：
（1）在多线程竞争下，加锁、释放锁会产生上下文切换和调度耗时。
（2）当一个线程持有锁事，其它所有需要此锁的线程必须挂起等待。
（3）优先级高的线程和优先级低的线程无法区分。
虽然，volatile是一个潜在的解决方案，但是volatile不能保证原子性。因此最终还要从锁机制上找答案。
本文将以令狐冲和任盈盈对话的方式，展开此章节的描述，给本已枯燥的技术世界，增加一些趣味！

一、什么是CAS？

任盈盈：令狐哥，在讲CAS之前，我先给你灌输两个概念，乐观锁和悲观锁。

任盈盈：悲观锁又称为独占锁，比如synchronized就是一种独占锁，当某个线程抢占到独占锁后，其它所有需要锁的线程都会被挂起，等待持有锁的线程释放锁。

任盈盈：乐观锁又称为共享锁。乐观锁的思想就是，在访问临界变量的时候不加锁，并且假设该次访问没有冲，如果因为冲突失败就重试，直到成功为止。乐观锁用到的机制就是CAS，Compare and Swap。

令狐冲：盈盈，你这样一说，我就明白了。CAS的全称为Compare-And-Swap，直译就是对比交换。

任盈盈：对的，CAS是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，正是由于CAS操作是原子性的，所以多线程并发使用CAS更新数据时，可以不使用锁。

令狐冲：听说在Doug Lea提供的cucurenct包中，CAS理论是它实现整个java包的基石。JDK中大量使用了CAS来更新数据而防止加锁(synchronized 重量级锁)来保持原子更新。

任盈盈：简单的来说，CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则返回V。

令狐冲：这是一种乐观锁的思路，它相信在它修改之前，没有其它线程去修改它；而Synchronized是一种悲观锁，它认为在它修改之前，一定会有其它线程去修改它，悲观锁效率很低。

任盈盈：下面来看一下如何利用CAS实现原子性操作的吧。

二、如何使用CAS

1.原子包atomic

任盈盈：CAS毕竟是一个靠硬件实现的理念，但是如果想在JVM中使用，就需要落地实现，在Java并发包中有这样一个包，java.util.concurrent.atomic，该包是对Java部分数据类型的原子封装，在原有数据类型的基础上，提供了原子性的操作方法，保证了线程安全。

令狐冲：干说多没有意思，举个例子说说嘛。

任盈盈：那我就以下面以atomic包下的AtomicInteger类为例，来看一下是如何实现的吧。首先看下这个类如何使用：

public class Test {
    private  AtomicInteger i = new AtomicInteger(0);
    public int add(){
        return i.incrementAndGet();
    }
    
    public int dec(){
        return i.decrementAndGet();
    }
}

任盈盈：我们在看下这两个方法的具体实现：

public final int incrementAndGet() {  
    for (;;) {  
        int current = get();  
        int next = current + 1;  
        if (compareAndSet(current, next))  
            return next;  
    }  
}

任盈盈：这是自增方法，incrementAndGet方法相当于原子性的++i，此处没有使用synchronized或者其它方式来保证原子性。

public final int decrementAndGet() {  
	//如果不更新成功，就一直循环！！！！
    for (;;) {  
        int current = get();  
        int next = current - 1;  
        if (compareAndSet(current, next))  
            return next;  
    }  
}

任盈盈：decrementAndGet方法相当于原子性的–i，自减操作。这两个方法中都没有使用阻塞式的方式来保证原子性（如Synchronized），且底层都调用了compareAndSet方法。

令狐冲：这个compareAndSet其实就是我们说的Compare and Swap的java实现吧，天上飞的理念，都有落地的实现，这个实现还悄悄地的换了一个名字。

令狐冲：那compareAndSet这个方法咋实现的呢？

任盈盈：继续往下看：

// setup to use Unsafe.compareAndSwapInt for updates  
private static final Unsafe unsafe = Unsafe.getUnsafe();  
private static final long valueOffset;// 注意是静态的  
  
static {  
  try {  
    valueOffset = unsafe.objectFieldOffset  
        (AtomicInteger.class.getDeclaredField("value"));// 反射出value属性，获取其在内存中的位置  
  } catch (Exception ex) { throw new Error(ex); }  
}  
  //重点呀！！！
public final boolean compareAndSet(int expect, int update) {  
  return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
}

任盈盈：这里利用Unsafe类的JNI方法实现，使用CAS指令，可以保证读-改-写是一个原子操作。compareAndSwapInt有4个参数，this - 当前AtomicInteger对象，Offset - value属性在内存中的位置(需要强调的是不是value值在内存中的位置)，expect - 预期值，update - 新值，根据上面的CAS操作过程，当内存中的value值等于expect值时，则将内存中的value值更新为update值，并返回true，否则返回false。

令狐冲：咦？这个unsafe类从名字上来看，不安全，这是咋回事呀？

任盈盈：这都被你发现了！确实，这个类是用于执行低级别的、不安全操作的方法集合，这个类中的方法大部分是对内存的直接操作，所以不安全，但当我们使用反射、并发包时，都间接的用到了Unsafe。

任盈盈：为啥有这个类需要扯点历史了，话说当年程序世界都被C++大佬们把控着，任何新生的语言都无法完全绕开C++去自己实现，java也不例外，由于java无法直接访问底层的操作系统，需要通过本地的native方法来访问，unsafe类就相当于一个后门，基于该类可以直接操作特定内存的数据。

任盈盈：unsafe类中的所有方法都是native修饰的，也就是说unsafe类中的方法都直接调用操作系统底层资源执行相应的任务。

令狐冲：哦哦，就是涉及到native修饰的方法，其实底层都是间接调用了c++的方法，我说咋点击调用链，咋点不动呢。。。。

2.CAS缺点

令狐冲：说了这么多，那CAS有啥缺点吗？面试的时候，我可是被问到了呀。

任盈盈：CAS虽然很高效的解决原子操作， 但是CAS仍然存在三大问题。ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作。

令狐冲：那啥事ABA问题呀？

任盈盈：因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。

令狐冲：那这个问题确实还是挺致命的呢，有啥好的解决办法吗？

任盈盈：ABA问题的解决思路就是使用版本号，类似于数据库的版本控制，。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。

令狐冲：哦哦，那就是类似于将每一条变量都标注成独一无二的，类似于给每个数据都打上一个时间戳嘛。

任盈盈：你这样理解也很好呀，其实，还真就是这样做的，从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。是不是和你的想法很像呀？

令狐冲：哈哈，那你继续说说循环时间长开销大是咋回事吧

任盈盈：还记得，，前面的代码中，有写道：CAS在执行自增自减的时候，如果不成功，会一直循环，直道成功为止！！（代码忘了的话，往前翻一番 for循环）

任盈盈：自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。

令狐冲：那为啥只能保证一个共享变量的原子操作？

任盈盈：当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。

任盈盈：还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i = 2，j = a，合并一下ij = 2a，然后用CAS来操作ij。

令狐冲：哈哈，从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。我厉害吧？

任盈盈：厉害，你很厉害！那CAS就全部讲完了！！