谈谈 volatile 关键字？_vnjohn-华为开发者空间

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

它的作用是：

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

由 volatile 关键字引申出一个概念，JMM 内存模型：

JMM(Java 内存模型 Java Memory Model，简称 JMM)本身是一种抽象的概念，并不真实存在，它描述的是一组规则，通过规范定制了程序中各个变量(包括实例字段，静态字段和构成数组对象的元素)的访问方式。

JMM 关于同步规定：

线程解锁前，必须把共享变量的值刷新回主内存
线程加锁前，必须读取主内存的最新值到自己的工作内存
加锁解锁是同一把锁

由于 JVM 运行程序的实体是线程，而每个线程创建时 JVM 都会为其创建一个工作内存(有些地方成为栈控件)，工作内存是每个线程的私有数据区域，而 Java 内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行，首先要将变量拷贝到自己的工作控件，然后对变量进行操作，操作完成后再将变量写回到主内存，不能直接操作主内存中的变量，各个线程中的工作内存储存着主内存中的变量副本拷贝，因此不同的线程无法访问对方的工作内存，此案成间的通讯(传值)必须通过主内存来完成，其简要访问过程如下图：

1.可见性

通过前面对 JMM 介绍，我们知道

各个线程对主内存中共享变量的操作都是各个线程各自拷贝到自己的工作内存操作后再写回主内存中的。

这就可能存在一个线程 AAA 修改了共享变量 X 的值还未写回主内存中时，另外一个线程 BBB 又对内存中的一个共享变量 X 进行操作，但此时 A 线程工作内存中的共享变量 X 对线程B来说并不可见，这种工作内存与主内存同步延迟现象就造成了可见性问题。

2.原子性

number++ 在多线程下是非线程安全的，如何不加 synchronized 解决？

volatileDemo 代码演示可见性 + 原子性代码

package com.concurrent.demo;
import java.util.concurrent.TimeUnit;
class MyData{
    volatile int number=0;
    public void addT060(){
        this.number=60;
    }
}
/**
 *  1.验证 volatile的可见性
 *      1.1 假如 int number=0;number变量之前根本没有添加volatile关键字修饰 没有可见性
 */
public class VolatileDemo {
    public static void main(String[] args) {//main是一切方法的主入口
        MyData myData=new MyData();//资源类
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t come in");
            try {
                //暂停一会儿线程
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.addT060();//三秒钟之后将number改值
            System.out.println(Thread.currentThread().getName()+"\t update number value:"+myData.number);
        },"AAA").start();

        //第2个线程就是我们的main线程
        while (myData.number==0){
            //main进程 测试不加volatile关键字是否有可见性
        }
        System.out.println(Thread.currentThread().getName()+"\t mission is over:"+myData.number);
    }
}

3.有序性

计算机在执行程序时，为了提高性能，编译器和处理器常常会做指令重排，一般分为以下三种：

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。

处理器在进行重新排序是必须要考虑指令之间的数据依赖性

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程使用的变量能否保持一直是无法确定的，结果无法预测。

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

1234

2134

1324

问题:

请问语句4 可以重排后变成第一条码?

存在数据的依赖性没办法排到第一个

4.volatile 使用

4.1 单例模式DCL代码

public class SingletonDemo {
    private static volatile SingletonDemo instance=null;
    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 构造方法");
    }

    /**
     * 双重检测机制
     * @return
     */
    public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance==null){
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }

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

4.2 单例模式volatile分析

DCL(双端检锁)机制不一定线程安全，原因是有指令重排的存在，加入 volatile 可以禁止指令重排

原因在于某一个线程在执行到第一次检测，读取到的 instance 不为 null 时，instance 的引用对象可能没有完成初始化。

instance=new SingletonDem(); 可以分为以下步骤(伪代码)
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.初始化对象

但是指令重排只会保证串行语义的执行一致性(单线程)并不会关心多线程间的语音一致性

所有当一条线程访问 instance 不为 null 时，由于 instance 实例未必完成初始化，也就造成了线程不安全问题。

谈谈 volatile 关键字？

vnjohn