• 【面试题】volatile关键字

    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;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    线程B的执行代码：

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

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

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    对应指令

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    所以通过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);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    在这里插入图片描述
    将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);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    在这里插入图片描述

    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();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    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
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    在这里插入图片描述

    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();
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

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

    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();
        }

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    在这里插入图片描述
    结果可以看出，最终只有一次实例化，但是由于指令重排，线程不一定安全（指令重排线程不安全，指令不重排线程安全）。
    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();
        }

    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    在这里插入图片描述

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

    ：

  • 相关阅读:
    组件中的数据存放问题
    AQS之Semaphore分析 (七)
    2022年10月 前端面试题总结——（二）
    UI自动化测试是什么？什么项目适合做UI自动化测试
    什么是跨域？什么是同源策略？如何解决Ajax跨域问题？什么是JSONP？JSONP怎么请求数据？什么是Proxy？Proxy怎么请求数据？
    数据库系列：使用高区分度索引列提升性能
    懒人福音：Java版Webhook机器人，一键开启‘躺赢’模式
    实现本地访问云主机，以及在云主机搭建FTP站点
    长尾关键词 挖掘出来的长尾关键词要怎么筛选？筛选条件有哪些
    docker 基本命令
  • 原文地址：https://blog.csdn.net/yzx3105/article/details/126590263