java面试常问关键词Volatile详解

请你谈谈你对Volatile的理解

Volatile是Java虚拟机提供的轻量级的同步机制(synchronized)

重要的三点:

1.保证可见性
代码:

package com.qiu.Volatile;

import java.util.concurrent.TimeUnit;

public class JmmDemo01 {
    //如果不加Volatile程序就会死循环
    
    private static int  num = 0;
    public static void main(String[] args) {//main

​        new Thread(()->
​        {//线程1,对主内存的变化是不知道的
​            while (num==0){

​            }
​        }).start();
​        try {
​            TimeUnit.SECONDS.sleep(1);
​        } catch (InterruptedException e) {
​            e.printStackTrace();
​        }
​        num=1;
​        System.out.println(num);
​    }
}

2.不保证原子性(事务中有ACID原则,其中就有原子性)
原子性:不可分割

线程A在执行任务的时候,不能被打扰的,也不能被分割,要么同时成功,要么同时失败.

验证代码:

package com.qiu.Volatile;

//volatile不保证原子性
public class VoDemo02 {
    private volatile static int num =0;

​    public  static void add(){
​        num++;//不是一个原子性操作
​    }
​    //理论上num的结果为20000
​    public static void main(String[] args) {
​        for (int i = 0; i < 20; i++) {
​            new Thread(()->{
​                for (int j = 0; j < 1000; j++) {
​                    add();
​                }
​            }).start();
​        }
​        while(Thread.activeCount()>2){
​            Thread.yield();
​        }
​        System.out.println(Thread.currentThread().getName()+"主线程"+num);
​    }
}

原则上num=20000;但是加上Volatile也没到20000,所以volatile不保证原子性
可以加Lock或者synchronized来保证原子性但是:
如果不加Lock和synchronized这两个锁怎么样保证原子性.
这个时候我们就要从底层分析了:
对于num++来说,并不是一个原子性的操作.
使用原子类去解决我们的原子性的问题

package com.qiu.Volatile;

import java.util.concurrent.atomic.AtomicInteger;

//volatile不保证原子性
public class VoDemo02 {
    //原子类的Intege
        private  static AtomicInteger num =new AtomicInteger();

​    public  static void add(){
​        num.getAndIncrement();//AtomicInteger的+1方法,但是getAndIncrement并不是一个简单的+1操作.
​        // 用的是底层的CAS,这是CPU的并发原理,效率极高
​    }
​    //理论上num的结果为20000
​    public static void main(String[] args) {
​        for (int i = 0; i < 20; i++) {
​            new Thread(()->{
​                for (int j = 0; j < 1000; j++) {
​                    add();
​                }
​            }).start();
​        }
​        while(Thread.activeCount()>2){
​            Thread.yield();
​        }
​        System.out.println(Thread.currentThread().getName()+"主线程"+num);
​    }
}

这个类的底层都直接和操作系统挂钩,在内存中修改值,Unsafe是一个很特殊的悬念.

3.禁止指令重排

什么是指令重排?

你写的程序,计算机并不是按照你写的那样执行的.

源代码->编译器优化的重排,指令并行也可能会重排,内存系统也会重排–>执行

处理器在进行指令重排的时候,考虑:数据之间的依赖性.

int x=1;	1
int y =2;	2
x=x+5;		3
y =x*x;		4
    我们所期望的是1234但是计算机不是这样执行的(2134,1324)都是能跑的
    但是不可能是4123.....
    

指令重排导致的诡异结果:x=2;y=1.(逻辑上和理论上是可能产生的)

Volatile可以避免指令重排:

内存屏障,cpu指令,作用:

1.保证特定的操作执行顺序

2.可以保证某些变量的内存可见性(利用这些特性,可以保证Volatile实现类可见性)

Volatile是可以保证可见性的,但是不能保证原子性,由于内存屏障,可以避免指令重排的现象产生

笔记自己看视频做的,视频链接如下:
B站地址：https://space.bilibili.com/95256449