【面试题】volatile关键字、单例模式（DCL）

已于 2023-02-10 14:12:30 修改
阅读量465 收藏
点赞数
分类专栏： 面试题-并发 文章标签： java 面试
于 2022-08-30 10:32:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzx3105/article/details/126590263
版权

volatile关键字

1.Volatile是什么

是java虚拟机提供的轻量级的同步机制

Volatile能保证什么

· 保证可见性
· 禁止指令重排
· 不保证原子性

如何保证可见性

volatile修饰的变量，在每个读操作（load操作）之前都加上Load屏障，强制从主内存读取最新的数据。每次在assign赋值后面，加上Store屏障，强制将数据刷新到主内存。

举例

volatile int = 0；线程A、B进行 i++ 的操作来画图给你讲解一下
在这里插入图片描述

  1. 线程A读取 i 的值遇到Load屏障，需要强制从主存读取得到 i = 0; 然后传递给工作线程执行++操作
  2. cpu执行 i++ 操作得到 i = 1，执行assign指令进行赋值；然后遇到Store屏障，需要强制刷新回主内存，此时得到主内存 i = 1
  3. 然后线程B执行读取 i 遇到Load屏障，强制从主内存读取，得到最新的值 i = 1，然后传给工作线程执行++操作，得到 i = 2，同样在赋值后遇到Store屏障立即将数据刷新回主内存

总结

说白了就是通过一个屏障让volatile的变量每次读都读主存，每次修改后立即刷到主存里面。
好比线程A修改 i 后立即将值刷到主存里面，后面线程B用到的时候强制从主存读取，这个时候它能看到的值是线程A修改之后的值了。也就是通过这种方式来保证多线程之间的可见性吧。

如何保证有序性

举例

线程A的执行代码：

// 步骤1
dataSource = initDataSource();
// 步骤2
httpClient = initHttpClient();
// 步骤3
initOK = true;

线程B的执行代码：

// 步骤4
while(!initOK) {
}
// 步骤5
Object data = dataSource.getData();
// 步骤6
httpClient.request(data);

由于线程A先执行了initOK = true。导致线程B提前跳出了while循环！！！，然后线程B调用dataSource.getData的时候发现dataSource没初始化好，竟然是个坑爹的null，导致代码报错了。

修改代码（initOk用volatile来修饰，是可以做到线程A有序性执行的）

// 步骤1
dataSource = initDataSource();
// 步骤2
httpClient = initHttpClient(); 
// 步骤3
volatile initOK = true;

对应指令

// 步骤1  对应上面dataSource = initDataSource();
store datasource指令
// 步骤2  对应上面httpClient = initHttpClient();
store http指令
 
StoreStore屏障  （注意：在store initOK前面加了一个StoreStore屏障）
// 步骤3  对应上面initOK = true;
store initOk = true指令
StoreLoad 屏障 （注意：在store initOK后面加了一个StoreLoad屏障）

所以通过volatile修饰initOK，加了屏障之后；store initOK = true 这一条指令是不能跳到store dataSource、store http前面去的，所以必须先执行完前面的执行之后，才能执行store initOK = true

这样对于线程B来说，加了内存屏障之后，它看到线程A就是资源初始化完成之后，才将initOK表示设置为true的，这样它看到线程A的执行就是有序的

2.JMM(java内存模型)

java内存模型规定所有变量存储在主内存（共享区域，对所有线程共享），jvm都会为每个线程分配一块工作内存（工作内存是每个线程的私有区域）。但线程不能直接操作主内存的数据，需要将主内存的数据拷贝到自己的工作内存就行修改，修改完成后写会主内存。

在这里插入图片描述

3. 测试三大特性

3.1 测试可见性

package com.leyantech.eci.ziying.controller.api.test;

import java.util.concurrent.TimeUnit;

 class MyData {
    int num = 0;

    void updateNum() {
        num = 60;
    }
}

public class VolatileDemo1 {
    public static void main(String[] args) {
        MyData myData = new MyData();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " come in");
            //休眠3秒
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.updateNum();
            System.out.println(Thread.currentThread().getName() + " update num" + myData.num);
        }, "AAA").start();

        while (myData.num == 0) {
			//
        }
        System.out.println(Thread.currentThread().getName() + " 主线程结束，num" + myData.num);
    }
}

在这里插入图片描述
将num用volatile修饰，会得到以下结果
在这里插入图片描述

3.2 测试原子性

一共20个线程，每个线程都调用num++，循环1000次，如果能保证原子性的情况下，数据应该是20000

class MyData {
    volatile int num = 0;

    void numAdd() {
        num++;
    }
}

public class VolatileDemo1 {
    public static void main(String[] args) throws InterruptedException {
        MyData myData = new MyData();

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    myData.numAdd();
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(5);

        System.out.println(Thread.currentThread().getName() + " 主线程结束，num:" + myData.num);
    }
}

在这里插入图片描述

3.2.1 为什么会出现以上情况

3.2.2 解决原子性

方法1： 增加sync关键字
方法2：int -> AtomicInteger（原子操作类）
方法3：使用 ReentrantLock

Lock lock = new ReentrantLock();
public void increase() {
    lock.lock();
    try {
        inc++;
    } finally {
        lock.unlock();
    }
}

class MyData {
    volatile int num = 0;

	//1.改为同步方法
    synchronized void numAdd() {
        num++;
    }

    //2.AtomicInteger原子操作
    AtomicInteger atomicInteger =new AtomicInteger();
    void atomicIntegerAdd(){
        atomicInteger.getAndIncrement();
    }
}

public class VolatileDemo1 {
    public static void main(String[] args) throws InterruptedException {
        MyData myData = new MyData();

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    myData.numAdd();
                    myData.atomicIntegerAdd();
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(5);

        System.out.println(Thread.currentThread().getName() + " 主线程结束，num:" + myData.num);	//改为同步方法后，num:20000
        System.out.println(Thread.currentThread().getName() + " 主线程结束，atomicInteger:" + myData.atomicInteger);//改为原子操作后，num：20000
    }
}

在这里插入图片描述

3.3 指令重排（了解）

volatile禁止指令重排，从而避免多线程环境下乱序执行。
首先来了解一下内存屏障，是一个CPU指令，他的作用有两个：
1.通过插入内存屏障，禁止编译器和处理器对内存屏障前后的指令进行重排优化；
2.强制刷出CPU的缓存数据，保证所有线程拿到的数据都是最新的。
在这里插入图片描述

4.单例模式

单例模式有懒汉模式和饿汉模式，饿汉模式无论单线程还是多线程都不会出问题(仅初始化一次)，饿汉模式在多线程由于判断等原因会导致多次初始化。

4.1 基础懒汉模式

public class Singleton {
    private static Singleton singleton;

    //构造私有化
    private Singleton() {
        System.out.println("实例化～");
    }

    //静态方法方便外部调用
    public static Singleton getInstance() {

        if (Objects.isNull(singleton)) {
            singleton = new Singleton();
        }
        return singleton;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                Singleton.getInstance();
            }).start();
        }

    }
}

在这里插入图片描述
结果可以看出，会被多次实例化

4.2 DCL（Double Check Lock）双端检锁机制 – （非最终版）

public class Singleton {
    private static Singleton singleton;

    //构造私有化
    private Singleton() {
        System.out.println("实例化～");
    }

    //静态方法方便外部调用
    public static Singleton getInstance() {
        //改动点1：DCL（Double Check Lock）双端检锁机制
        if (Objects.isNull(singleton)) {
            synchronized (Singleton.class) {
                if (Objects.isNull(singleton)) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                Singleton.getInstance();
            }).start();
        }

    }

}

在这里插入图片描述
结果可以看出，最终只有一次实例化，但是由于指令重排，线程不一定安全（指令重排线程不安全，指令不重排线程安全）。
new Singleton();是由3个指令完成操作，
1.分配内存空间
2.初始化对象
3.地址分配

由于指令2和指令3没有数据依赖关系，所以有可能会被重排，重排后的指令
1.分配内存空间
3.地址分配
2.初始化对象

重排后就会导致，某个线程拿到的对象可能是个空，线程不安全。

4.3 最终版

public class Singleton {
    //改动点2: volatile禁止指令重排
    private static volatile Singleton singleton;

    //构造私有化
    private Singleton() {
        System.out.println("实例化～");
    }

    //静态方法方便外部调用
    public static Singleton getInstance() {
        //改动点1：DCL（Double Check Lock）双端检锁机制
        if (Objects.isNull(singleton)) {
            synchronized (Singleton.class) {
                if (Objects.isNull(singleton)) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                Singleton.getInstance();
            }).start();
        }

    }

}

在这里插入图片描述

参考文章：
volatile怎么通过内存屏障保证可见性和有序性

：

桃月十二_
关注
专栏目录
volatile关键字相关面试题
weixin_41804367的博客
11-10 618
1、说说volatile关键字的特性 被volatile修饰的共享变量，就具有了以下两点特性： 保证了不同线程对该变量操作的内存可见性; 禁止指令重排序； 2、JMM有哪些特性？ 可见性，还有原子性和有序性。 3、volatile能保证原子性吗？ volatile不能保证原子性，它只是对单个volatile变量的读/写具有原子性，但是对于类似i 这样的复合操作就无法保证了。 如下代码...
Android面试题：单例模式
a_sid的博客
05-29 269
单例模式特征： 1.构造方法不对外开放，一般是private 2.一般通过一个静态方法或者枚举返回单例类对象 3.注意多线程的场景 4.如果单例对象可以被序列化，要注意单例对象在反序列化的时候不会重新创建对象 ...
面试之volatile关键字
qq_32712809的博客
02-28 396
java面试过程总会遇到不同的面试问题,今天我们就来聊聊volatile关键字, 因为这个关键字可以Java并发编程,java内存模型的一些特征都一个个牵扯进来, 更有甚者可以考察JVM的底层实现以及操作系统的相关知识, 所以面试官往往对volatile乐此不疲: 问题1: 说说你对volatile关键字的理解? 被volatile关键字修饰的变量具有以下两个特点: ...
面试题：volatile
qq_29860591的博客
12-30 245
volatile 1.volatile保证可见性 代码比较简单，我就不贴出来了。 子线程t从主内存读取到数据放入其对应的工作内存 将flag的值更改为true，但是这个时候flag的值还没有写会主内存 此时main方法main方法读取到了flag的值为false 当子线程t将flag的值写回去后，失效其他线程对此变量副本 再次对flag进行操作的时候线程会从主内存读...
2019面试题总结：volatile关键字（一）
qianfeng_dashuju的博客
12-03 235
面试时通过volatile关键字，全面展示线程内存模型的能力
hsm_computer的博客
01-21 1339
面试时，面试官经常会通过volatile关键字来考核候选人在多线程方面的能力，一旦被问题此类问题，大家可以通过如下的步骤全面这方面的能力。 1首先通过内存模型说明volatile关键字的作用 先说明，用volatile修饰的变量，能直接修改内存内容，修改后的变量对其他线程是可见的。然后展开说明如下的内容。 多线程并发操作同一资源时，可能会出现最终结果和预期不同的情况，刚才我们也已经通过线程安全和不安全相关的案例，直观地看到了这一情况，这里我们将通过线程的内存结构来详细...
面试题——单例模式
weixin_51020122的博客
05-16 265
单例模式的五种实现方式。 了解JDK中哪些地方体现了单例模式。 Runtime类（饿汉式）、System类（双检锁-懒汉式）、Collections工具类。可到idea中查看源码。 饿汉式 package com.jie.singleton; import java.io.Serializable; /** * @Author 小杰 * @Date 2022/5/16 15:10 * @Version 1.0 * 饿汉式 */ public class Singleton1 impl.
知名公司面试题：谈谈你对volatile关键字的理解
爱开发
06-29 1253
作为一名java程序员，求职面试时，关于volatile关键字时常会遇到。张工最近到某知名互联网公司面试，面试官提出这样的一个问题：谈谈你对volatile关键字的理解张工一时间没有回答...
面试题—5种单例模式写法以及单线程和多线程下的区别
在路上
06-17 2252
闲来无事看之前的博客，发现单例模式只会写2中。所以再重新开一篇博客，将目前自己所能理解的几种单例模式全部总结下。 ______________________________________________________________________________________________________________________ 1、懒汉式（最基本的） 单线程版 写单例模式(饿汉式)的步骤： 1):必须在该类中,自己先创建出一个对象。 2):私有化自身的...
静态内部类实现单例_单例模式详解
weixin_39713814的博客
12-08 4501
概述单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，使用单例模式的类只有一个对象实例。单例应用场景Windows系统的任务管理器。Windows系统的回收站。操作系统的文件系统，一个操作系统只能有一个文件系统。数据库连接池的设计与实现。多线程的线程池设计与实现。Spring中创建的Bean实例默认都是单例。Java-Web中，一个Ser...
【面试】Volatile常见面试题
HeavenDan的博客
10-29 2450
1.运算结果不依赖变量的当前值。 2.变量不需要与其他的转态变量共同参与不变的约束。 PS:第一个条件的理解：volatile变量不能是自增量（如x++），x++ 实际是三步运算，① 获得 x 值；② 修改 x 值；③ 将 x 值写回内存； 第二个条件的理解：不变的约束即为条件表达式（start < end），若表达式使用了两个及以上的变量（不管是否是volatile变量）就无法保证正确性，也就是说不变式会失效。
【并发】volatile关键字面试整理
ss123mlk的博客
06-29 320
volatile变量的特性？ volatile变量的内存语义？ volatile指令重排序的特点？ volatile内存语义是怎么实现的？
面试系列-volatile关键字详解
Java 架构师之路
06-12 198
作者：海子https://www.cnblogs.com/dolphin0520/p/3920373.htmlJava架构师之路做了编排和配图volatile关键字虽然从...
2019面试题总结：volatile关键字（二）
qianfeng_dashuju的博客
12-03 172
volatile 关键字，你真的理解吗？
Star's Tech Blog
05-06 2402
这里我们将引出一个概念：内存屏障指令 内存屏障指令 为了实现 volatile 内存语义（即内存可见性），JMM 会限制特定类型的编译器和处理器重排序。为此，JMM 针对编译器制定了 volatile 重排序规则表，如下所示： 使用 volatile 修饰变量时，根据 volatile 重排序规则表，Java 编译器在生成字节码时，会在指令序列中插入内存屏障指令来禁止特定类型的处理器重排序。 内...
volatile面试题总结
HRX98的博客
03-10 1674
1. 说说你对volatile关键字的理解 volatile是java虚拟机提供的轻量级的同步机制 保证可见性 不保证原子性 保证有序性 2. 能不能详细说下什么是内存可见性，什么又是重排序呢？ 2.1 内存可见性 这个需要从Java内存模型说起 在目前的计算机中，CPU的计算速度远远大于计算机存储数据的速度，但是内存访问的速度就慢了很多。为了提升整体性能，在CPU和内存之间加入了高速缓存。 CPU将计算需要用到的数据暂存进缓存中。当计算结束后再将缓存中的数据存入到内存中。这样CPU的运算可以在缓存中
面试必问的volatile，你了解多少？
weixin_33748818的博客
01-25 152
占小狼 转载请注明原创出处，谢谢！ 前言 Java中volatile这个热门的关键字，在面试中经常会被提及，在各种技术交流群中也经常被讨论，但似乎讨论不出一个完美的结果，带着种种疑惑，准备从JVM、C++、汇编的角度重新梳理一遍。 volatile的两大特性：禁止重排序、内存可见性，这两个概念，不太清楚的同学可以看这篇文章 -&gt; java volatile关键字解惑 概念是知道了，但还...
面试中的volatile关键字
ArvinYL
05-04 272
在Java的面试当中，面试官最爱问的就是volatile关键字相关的内容。经过多次面试之后，你是否思考过，为什么他们那么爱问volatile关键字相关的问题？而对于你，如果作为面试官，是否也会考虑采用volatile关键字作为切入点呢？ 为什么爱问volatile关键字 爱问volatile关键字的面试官，大多数情况都是有一定功底的，因为volatile作为切入点，往底层走可以切入Java内存模型...
单例模式为啥使用volatile关键字
最新发布
09-15
在单例模式中，使用volatile关键字的主要目的是为了保证实例化对象的可见性和有序性。在没有使用volatile关键字的情况下，由于指令重排的存在，可能会导致在多线程环境下获取到一个未完全初始化的实例。这可能会导致对未初始化对象进行操作，引发程序错误。 使用volatile关键字可以禁止指令重排，确保在对象实例化的过程中，所有的操作都按照指定的顺序进行。这样就可以保证在多线程环境下，所有线程都能正确地获取到完全初始化的实例。 简而言之，使用volatile关键字可以保证单例对象的可见性和有序性，避免了双重检查加锁模式中的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值