Java面试题（JUC&JVM）

最新推荐文章于 2024-07-23 12:23:52 发布

从现在开始壹并超

最新推荐文章于 2024-07-23 12:23:52 发布

阅读量306

点赞数 1

分类专栏： java&框架文章标签： java 面试后端

本文链接：https://blog.youkuaiyun.com/m0_45971439/article/details/123397985

版权

java&框架专栏收录该内容

21 篇文章

订阅专栏

面试题之Volatile，CAS

1. 请谈一下关于volatile的理解
2. CAS

1. 请谈一下关于volatile的理解

volatile是JVM提供的轻量级同步机制
- 保证可见性
- 不保证原子性
- 禁止指令重排
java内存模型（JMM）：是一种抽象的概念，并不真实存在，描述的是一组规则或规范。定义了程序中对每个变量的访问方式

java内存模型中规定所有变量都存储在主内存，主内存是共享的内存区域，所有线程都可以访问，但是线程对变量的操作（读取赋值等）必须在工作内存中进行。首先将变量从主内存中拷贝到线程自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写会主内存，不能直接操作主内存的变量，各个线程的工作内存中存储的是主内存的变量副本，因此不同的线程间无法访问对方的工作内存，线程间通信必须通过主内存来完成
关于可见性：存在一个线程A修改了共享变量X的值但还未写到主内存时，另一个线程B又对主内存中同一个共享变量X进行操作，此时A线程工作内存中的共享变量X对线程B而言是不可见的，这种工作内存与主内存的同步延迟现象造成了可见性问题

可见性的代码验证：

class MyNumber{
    volatile int a = 10;

    public void change(){
        this.a = 1024;
    }
}
public class VolatileSeeDemo {

    public static void main(String[] args) {

        MyNumber number = new MyNumber();
        new Thread( () -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            number.change();
            System.out.println(Thread.currentThread().getName() + " 更新后的参数a= " + number.a);
        }, "t1").start();

        // 需要有一种机制告诉main进程a被修改了(由于不同的线程之间无法直接通信)
        // 在变量a上加上volatile 可以完成同步
        while(number.a == 10){

        }
        System.out.println(Thread.currentThread().getName() + "====main ending====");
    }
}

关于原子性：不可分割，完整性，也就是某个线程正在执行某个业务时，中间不可以被加塞或者分割，需要整体完成要么同时成功要么同时失败。

对于i++操作，如果存在多个线程调用，在某一个线程进行+1并且要写回到主内存的同时，存在另一个线程来抢占也需要写数据，发生写覆盖；

不保证原子性的代码验证：

class Auto{
    volatile int num = 0;

    public synchronized void set() {
        num ++;
    }
    AtomicInteger atomicInteger = new AtomicInteger();
    public void add(){
        // Atomically decrements by one the current value.
        atomicInteger.getAndIncrement();

    }
}
// num++被拆分成3个指令：执行getfield得到原始的num；执行iadd进行加1操作；执行putfield将累加后的值写回主内存
// 将写回去的同时，存在线程抢占资源，因此造成了写覆盖，最终的值小于20000
public class VolatileDemo {

    public static void main(String[] args) {

        Auto auto = new Auto();
        for (int i = 1; i <= 20; i++) {
            new Thread( () -> {
                for (int j = 1; j <= 1000; j++) {
                    auto.set();
                    auto.add();
                }
            }, String.valueOf(i)).start();
        }
        // 当上面的20个线程没有结束 则main线程不执行(运行态 -> 就绪态)
        while(Thread.activeCount() > 2){
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName() + "\t int type, 当前的num：" + auto.num);
        System.out.println(Thread.currentThread().getName() + "\t AtomicInteger type, 当前的num：" + auto.atomicInteger);
    }
}

解决：

使用synchronized来修饰需要执行的方法之前
使用JUC下面的atomic包下的AtomicInteger（原子整型），在完整的一次++操作中只能由一个线程进行抢占
关于指令重排：单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致，CPU进行重排指令时需要考虑的数据依赖性。多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程使用的变量能否保证一致性是无法确定的，结果也就无法预测

总结：

工作内存和主内存的同步延迟现象导致的可见性问题，可以使用synchronized或者volatile关键字解决，都可以使一个线程修改后的变量立即对其他线程可见
对于指令重排导致的可见性问题和有序性问题，可以利用volatile来解决，由于volatile可以实现禁止指令重排（按照代码执行顺序去执行）

DCL Double Check Lock双端检锁机制(加入同步代码快进行两次检索)
但是该机制不一定线程安全，原因是指令重排的存在，加入volatile可以禁止指令重排；

由于下面的语句instance = new SingletonDemo(); 可能存在指令重排后：一个线程访问instance不为null时，由于instance实例未必已经完成初始化操作，仅仅是分配了内存地址，所以instance可能会被多次创建，也就成为了多例对象，造成了线程安全问题。所以在DCL的基础上对instance变量进行volatile修饰，禁止对该变量的指令重排，保证每次创建的instance都是单例的

public class SingletonDemo {

    private static volatile SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName() + "\t SingletonDemo构造方法....");
    }
    // DCL Double Check Lock双端检锁机制(加入同步代码快进行两次检索)
    public static SingletonDemo getInstance(){
        if(instance == null){
            synchronized (SingletonDemo.class){
                if(instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {

//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());

        for(int i=1; i<=10; i++){
            new Thread( () -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

2. CAS

比较并交换Compare and Swap，一条CPU的并发语句

对于AtomicInteger的getAndIncrement方法的源码：调用的是unsafe类的getAndAddInt方法，其三个参数分别为

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

this当前对象；valueOffset内存偏移量（内存地址）；固定值1

Unsafe类是什么？
请添加图片描述

是CAS的核心类，由于Java方法无法直接访问底层OS，需要通过本地方法（native）来访问。Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在sun.mics包中，其内部方法操作可以像C的指针一样直接操作OS，因为Java中CAS操作的执行依赖于Unsafe类的方法

注解Unsafe类中的所有方法都是native修饰的，即Unsafe类中的方法都是直接调用OS底层资源执行任务

变量valueOffset：该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址来获取数据的
变量value用的是volatile修饰，保证了多线程之间的内存可见性

CAS思想（自旋）

判断内存中某个位置的值是否为预期值，如果是预期值则更进行更新修改，这个过程是原子性的

调用Unsafe类中的CAS方法，JVM帮助实现CAS汇编指令，完全依赖于硬件的功能，通过他实现原子操作。由于CAS是一种系统原语，属于OS原语（执行必须是连续的，在执行过程中不允许被中断，即CAS是一条CPU的原子指令，不会造成数据不一致问题）

请添加图片描述 var1：AtomicInteger对象本身

var2：该对象值的引用地址

var4：需要变动的值

var5：通过var1和var2找出的主内存中的真实值

用该对象当前的值与主内存的值var5进行比较。如果相同，则更新var5+var4并且返回true；如果不同，继续取值再比较，直至更新完成

举例分析：

假设线程A和线程B两个线程同时执行getAndAddInt操作（分别跑在不同CPU上）：

AtomicInteger里面的value初始值为3，即在主内存中AtomicInteger的value为3，根据JMM模型，线程A和B各自持有一个value=3的副本在各自的工作空间中
线程A通过getIntVolatile拿到value值为3，此时A被挂机
线程B通过getIntVolatile得到value值为3，此时B没有被挂起并且执行compareAndSwapInt方法去比较内存值也为3，成功修改内存值value为4，此时线程B执行结束
这时线程A恢复，执行compareAndSwapInt方法去比较，发现手中的value为3，与主内存中的value=4不相等，说明value已经被修改了，A线程本次修改失败，只能重新进行一遍
线程A重新获取value值，由于vlaue被volatile修饰，因此某个线程对他的修改，A总是能看到，A继续执行compareAndSwapInt方法去比较替换，直至成功。

比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作；否则继续比较直到主内存和工作内存中的值一致即可
CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B；当前仅当预期值A与内存值相同时，将内存值V修改成B，否则什么都不做

CAS的缺点：

循环时间长开销很大
只能保证一个共享变量的原子操作，对于多个共享变量的原子操作，CAS无法保证，只能使用加锁机制
引起ABA问题

ABA问题的原因：

CAS实现一个重要前提需要取出内存中某时刻的数据并且在当前时刻进行比较替换，那么这个时间差会导致数据的变化

如一个线程A从内存位置V取出x，这时另一个线程B也从内存中取出x，并且线程B进行了一些操作将值修改成y。然后线程B又将位置V的值修改成x，这时候线程A进行CAS操作发现内存中依旧是x，然后线程A可以进行比较替换操作。

尽管线程A的CAS操作成功，但是不代表这个过程是没有问题的

原子引用（AtomicReference）更新

如何规避ABA问题：

新增一种机制，就是每次修改值的同时版本号跟着修改（类似时间戳）时间戳的原子引用AtomicStampedReference

演示AtomicReference和AtomicStampedReference：

package com.hz.Interview;


import com.hz.domain.Person;

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

public class CASDemo {

    public static void main(String[] args) {
        // Unsafe类 + CAS
        AtomicInteger atomicInteger = new AtomicInteger(1);

        System.out.println(atomicInteger.compareAndSet(1, 2022) + "\t current data: " + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(100, 2020) + "\t current data: " + atomicInteger.get());

        System.out.println("===========atomic reference================");
        Person person1 = new Person(1, "jinx", 20);
        Person person2 = new Person(2, "zed", 25);
        AtomicReference<Person> atomicReference = new AtomicReference<>();
        atomicReference.set(person1);
        System.out.println(atomicReference.compareAndSet(person1, person2) + "\t" + atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(person1, person2) + "\t" + atomicReference.get().toString());

        System.out.println("========================ABA question=====================");
        AtomicReference<Integer> atomicReference1 = new AtomicReference<Integer>(100);
        new Thread( () -> {
            atomicReference1.compareAndSet(100, 101);
            atomicReference1.compareAndSet(101, 100);
            System.out.println(Thread.currentThread().getName() + "\t 执行结束");
        }, "t1").start();

        new Thread( () -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference1.compareAndSet(100, 2022) + "\t" + atomicReference1.get());
        }, "t2").start();


        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("=========================ABA 解决==================");
        AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<Integer>(10, 1);
        new Thread( () -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t 第一次版本号：" + stampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 修改再修改回去 t3做一次ABA操作
            stampedReference.compareAndSet(10, 99, stampedReference.getStamp(), stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() + "\t 第二次版本号：" + stampedReference.getStamp());
            stampedReference.compareAndSet(99, 10, stampedReference.getStamp(), stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() + "\t 第三次版本号：" + stampedReference.getStamp());
        }, "t3").start();

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t 第一次版本号：" + stamp);
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("修改成功？" +
                    stampedReference.compareAndSet(10, 2022, stamp, stamp + 1)
            + "\t 当前最新版本号：" + stampedReference.getStamp());
            System.out.println(Thread.currentThread().getName() + "\t 当前最新值：" + stampedReference.getReference());
        }, "t4").start();
    }
}