【CAS】大厂面试出现频率最多之一，全面解析！宁还在等什么？

最新推荐文章于 2024-07-21 18:17:57 发布

AA-Jessica

最新推荐文章于 2024-07-21 18:17:57 发布

阅读量307

点赞数 1

分类专栏：面试

本文链接：https://blog.csdn.net/qmqm33/article/details/105069211

版权

面试专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、CAS

1.什么是CAS（CompareAndSwap）

1.1核心：比较并交换

CAS的全称为Compare-And-Swap,他是一条CPU并发原语
它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的
比较当前工作内存种得值和主内存种的值，如果相同则执行规定操作，否则继续比较直到主内存和工作内存种的值一致为止

1.2 具体实例图解

在这里插入图片描述

此图出自尚硅谷周阳老师
一开始,我给主物理内存设置值为5
第一个线程来了,要跟内存比较并交换,线程的期望值是 5 ,而刚好内存值就是5, 然后就交换了值,也就是把主物理内存的值5改为了2019,然后返回了个true代表取到的值与期望值是一样的
然后通知其他线程可见了,第二个线程来了,发现主物理内存是2019,跟自己的期望值5不一样啊,然后就返回了个false,主物理内存并没有改变~.

1.3 在大厂面试种经常提到

在这里插入图片描述

1.4核心底层思想

Unsafe+自旋锁！！！！回答这两句话就可！

2.Unsafe 的闪亮出场

2.1 出场条件

当我们使用atomiclnteger.getAndlncrement的时候，不需要加synchronized也能在多线程下保持线程安全。那是因为unsafe的存在。

2.2 Unsafe

是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native) 方法来访问，Unsafe相当于-一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一-样直接操作内存，因为Java中Unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native) 方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。
Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务
注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务

3.CAS的体现

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类种的各个方法，调用Unsafe类种的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统中用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行股票城中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓数据不一致的问题。
首先, var1代表当前对象,var2代表对象的偏移地址,var4就是那个+1的值
然后getIntVolatile()这个方法去获取当前对象的这个值是多少,给他保存到var5
然后,过了一会,compareAndSwapInt()这个方法去再比较当前对象的值还是不是var5,是的话就给这个值+1,返回true,while里面就是false就退出循环,最后返回出+1后的值. 如果当前对象不是之前的var5了,返回一个false,while循环里面就是true,继续循环,拿到下一个值去比较,直到比较成功~

3.1 图解

在这里插入图片描述

假设有两个线程AB,根据上面的内存模型来看 AtomicInteger 里面的value原始值为5，即主内存中AtomicInteger的value为5，根据JMM模型，线程A和线程B各自持有一份值为5的value的副本分别到各自的工作内存。
线程A通过getIntVolatile(var1, var2)拿到value值5，这时线程A被挂起。
线程B也通过getlntVolatile(var1, var2)方法获取到value值5，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为5，成功修改内存值为6，线程B打完收工，一切OK。
这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字5和主内存的值数字6不一致，说明该值已经被其它线程抢先一步修改过了，那A线程本次修改失败，只能重新读取新来一遍了。
线程A重新获取value值，因为变量value被volatile修饰，所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。

3.CAS应用

CAS有三个操作数，内存值V，旧的预期值A，要修改的更新值B
当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

4.CAS缺点

循环时间长开销大，因为其中有个do-while
只能保证一个共享变量的原子操作
引出来ABA问题

二、面试中CAS问题深入

2.1基本流程

CAS–>ＵnSafe–>CAS底层思想–>ABA–>原子引用更新–>如何规避ABA问题

三、ABA问题

核心：狸猫换太子

1.CAS导致的“ABA问题”

CAS算法实现了一个重要前提需要取出内存某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化
比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将变成了B,然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功
尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的，因为当把期待值由100到101 在到100，当下一次调用的时候还是100，就默认没有被修改过可以继续修改，所以这可能会出现问题

package com.kaikai.java;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class Test01 {

    static AtomicReference<Integer> atomicReference=new AtomicReference<>(100);

    public static void main(String[] args) {
        new Thread(()->{
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"t1").start();
        new Thread(()->{
            //保证t1已经完成了一次ABA操作
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100,2019)+"\t"+atomicReference.get());
        },"t2").start();
    }
}

1.1 原子引用 AtomicReferenceDemo

如果你觉得jdk默认给你例如AtomiInterger等不够，你可以引入AtomicReference
例如：AtomicReference

1.2时间戳原子引用

就是加上版本号，你脚踩的以前不是去年的那条河了！

 //初始化时间戳
    static AtomicStampedReference<Integer> atomicStampedReference=new AtomicStampedReference<>(100,1)；

具体操作在下面

1.3解决ABA问题：

理解原子引用＋新增一种机制，那就是修改版本号（类似于时间戳）

package com.kaikai.java;

import javax.persistence.criteria.CriteriaBuilder;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class Test01 {

    static AtomicReference<Integer> atomicReference=new AtomicReference<>(100);
    //初始化时间戳
    static AtomicStampedReference<Integer> atomicStampedReference=new AtomicStampedReference<>(100,1);

    public static void main(String[] args) throws InterruptedException {

        //ABA问题的产生
        System.out.println("========//ABA问题的产生========");
        new Thread(()->{
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"t1").start();
        new Thread(()->{
            //保证t1已经完成了一次ABA操作
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100,2019)+"\t"+atomicReference.get());
        },"t2").start();

        //ABA问题的解决
        
        TimeUnit.SECONDS.sleep(2);
        System.out.println("========ABA问题的解决========");
        new Thread(()->{
            //获取版本号
            int stamp=atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t第1次版本号："+stamp);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t第2次版本号："+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t第3次版本号："+atomicStampedReference.getStamp());
        },"t3").start();

        new Thread(()->{
            int stamp=atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t第1次版本号："+stamp);
            //保证上面的完成操作后
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result=atomicStampedReference.compareAndSet(100,2020,stamp,atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t修改是否成功："+result+"当前值"+atomicStampedReference.getReference()+"当前的版本号："+atomicStampedReference.getStamp());
        },"t4").start();

    }
}

四、自旋锁

1.自旋锁概念（spinLock）

是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU
如上图所示，当你取锁失败之后，在不断的去取，进行循环，直到可以取到为止。约女神绝不放弃，每隔一断时间就去约一次，直到女神答应为止。

2. 来肝个自旋锁代码

要求t1，t2完成取锁还锁
在t1换锁之前，t2用自旋锁方法获取锁
直到t1还锁之后，t2才可以得到锁还锁
代码如下

package com.kaikai.java;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class SpinLockDemo {
    AtomicReference<Thread> atomicReference=new AtomicReference<>();
    //获得锁
    public void myLock(){
        Thread thread=Thread.currentThread();
        //如果不是空就一直循环，直到自己获得为止
        while (!atomicReference.compareAndSet(null,thread)){}
        System.out.println(Thread.currentThread().getName()+"\t"+"come in");
    }

    //释放锁
    public void myUnlock(){
        Thread thread=Thread.currentThread();
        System.out.println(thread);
        boolean result=atomicReference.compareAndSet(thread,null);
        System.out.println(thread.getName()+"\t"+result+"\t invoke myUnlock");
    }

    public static void main(String[] args) throws InterruptedException {
        SpinLockDemo spinLockDemo =new SpinLockDemo();

        new Thread(()->{
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        },"t1").start();

        //确保第一个线程执行完
        TimeUnit.SECONDS.sleep(3);
        new Thread(()->{
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        },"t2").start();
    }
}

AA-Jessica

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【CAS】大厂面试出现频率最多之一，全面解析！宁还在等什么？

文章目录一、CAS1.什么是CAS（CompareAndSwap）1.1核心：比较并交换1.2 具体实例图解1.3 在大厂面试种经常提到1.4核心底层思想2.Unsafe 的闪亮出场2.1 出场条件2.2 Unsafe3.CAS的体现3.1 图解3.CAS应用4.CAS缺点二、面试中CAS问题深入2.1基本流程三、ABA问题核心：狸猫换太子1.CAS导致的“ABA问题”1.1 原子引用 Atom...
复制链接

扫一扫