01-021【jvm】聊聊volatile

volatile

概念：是java虚拟机提供的轻量级的同步机制
性质：保证可见性；不保证原子性；禁止指令重排
涉及：JMM.

1. 保证可见性

1. 验证volatile的可见性
   假如int number = 0;number变量之前根本没有添加volatile关键字修饰，则 没有通知main线程number的修改，所以不会退出循环

package com.magic.juc0117;

import java.util.concurrent.TimeUnit;

class MyData{
	//添加volatile关键字修饰后，number修改其他线程立即可见
    volatile int number = 0;
    public void addTo60(){
        this.number = 60;
    }
    public void addPlusPlus(){
        this.number++;
    }
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addAtomic(){
        atomicInteger.getAndIncrement();
    }
}

public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        new Thread(() -> {
            try{
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e){
                throw new RuntimeException(e);
            }
            myData.addTo60();
            System.out.println(Thread.currentThread().getName()+ " come in");

        },"AAA").start();
        
        //main线程
        while (myData.number == 0){
            //main线程一直在这等待循环，直到number值不再等于0
        }
        System.out.println(Thread.currentThread().getName()+"  over");
    }
}

2. 不保证原子性

验证原子性相关问题：

1. 原子性：不可分割，完整性，线程做任务中间不可以加塞
2. volatile不保证原子性代码演示
3. 为什么不能等于20000？
   volatile轻量级，不保证原子性，number++分为三步：从字节码文件看到（获取》加1》赋值） 底层来看number是共享变量，多线程竞争调度，线程很快，可能会丢失数据，俗称写覆盖
4. 如何解决不保证原子性问题？①加锁，浪费②AtomicInteger（代码演示）
5. 为什么AtomicInteger就可以保证原子性啦？底层原理CAS.

package com.magic.juc0117;

import java.util.concurrent.TimeUnit;

class MyData{
    volatile int number = 0;

    public void addTo60(){
        this.number = 60;
    }

    public void addPlusPlus(){
        this.number++;
    }
    
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addAtomic(){
        atomicInteger.getAndIncrement();
    }
}

public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    myData.addPlusPlus();
                    myData.addAtomic();
                }
            },String.valueOf(i)).start();
        }
        //需要等待上面20个线程都全部计算完成后，再用main线程取得最终的结果值看是多少
        while (Thread.activeCount() > 2){
            Thread.yield();//礼让线程
        }
        System.out.println(myData.number);
        System.out.println("atomic"+myData.atomicInteger);
    }
}

3.有序性

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排，一般分为以下三种
源代码》编译器优化的重排》指令并行的重排》内存系统的重排》最终执行的指令
单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。
处理器在进行重排序时必须考虑指令之间的数据依赖性。
多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。
举例1：

public void mySort(){
	int x = 11;//语句1
	int y = 12;//语句2
	x = x + 5;//语句3
	y =  x*x;//语句4
}

1234
2134
1324
问题：请问语句4可以重排后变成第一个执行的吗？不可以，数据依赖性
举例2：
int a,b,x,y =0;

线程1	线程2
x=a;	y=b;
b=1;	a=2

结果 x=0 y=0
如果编译器对这段程序代码执行重排优化后，可能出现下列情况

线程1	线程2
b=1;	a=2
x=a;	y=b;

结果 x=2 y=1
所以有禁止指令重排的必要
案例3：

public class ReSortSeqDemo{
	int a = 0;
	boolean flag = false;
	public void method1(){
		a = 1;
		flag = true;
	}
	//多线程环境中线程交替执行，由于编译器优化重排的存在，
	//两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测
	public void method1(){
		if(flag){
			a = a + 5;
			System.out.println("a="+a);
		}
	}
}

volatile实现禁止指令重排优化，通过插入内存屏障（Memory Barrier）禁止在内存屏障前后的指令执行重排序优化。
对volatile变量进行写操作时，在写操作后加入一条store屏障指令，将工作内存中的共享变量值刷新回主内存；
对volatile变量进行读操作时，在读操作前加入一条load屏障指令，从主内存中读取共享变量。

4.在哪用到了volatile

package com.magic.juc0117;

public  final  class  Singleton{
    private  Singleton(){
        System.out.println("构造方法");
    }
    private  static volatile Singleton  INSTANCE  =  null;
    //DCL  （Double Check Lock双端检锁机制）没有用volatile时，因为存在指令重排，不一定安全
    //原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化
    //INSTANCE = new Singleton();可以分成以下3步（伪代码）
    //memory = allocate();1.分配对象的内存空间
    //instance(memory); 2.初始化对象
    //instance = memory; 3.设置instance指向刚刚分配的内存地址，此时instance != null
    //步骤2和3不存在数据依赖关系
    //memory = allocate();1.分配对象的内存空间
    //instance = memory; 3.设置instance指向刚刚分配的内存地址，此时instance != null
    //instance(memory); 2.初始化对象
    //单线程指令重排没有影响，但是多线程会存在安全问题，应当保证多线程的语义一致性，加上volatile问题解决
    public  static  Singleton  getInstance(){
        if(INSTANCE == null){//实例没创建，才会进入内部的synchronized代码块
            synchronized  (Singleton.class){
                if(INSTANCE == null){//也许其他线程已经创建实例，所以再判断一次
                    INSTANCE = new Singleton();
                }
            }
        }
        return  INSTANCE;
    }

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

学习整理于面试题.