java volatile 关键字详解

1. 简介

volatile 关键字：当多个线程进行操作共享数据时，可以保证内存中的数据可见。
相较于 synchronized 是java虚拟机提供的一种较为轻量级的同步策略。

主要有以下特性：

1. 可见性
2. 禁止指令重排

注意：
3. volatile 不具备“互斥性”
4. volatile 不能保证变量的“原子性”

2.可见性详解

2.1 JMM(java 内存模型) 简介

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

JMM关于同步规定:

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

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

2.2 可见性

前面在JMM中介绍说了 ，共享变量统一存在主内存中，而各个线程想要修改这个变量的值，就需要先从主内存中把共享变量的值，拷贝到自己的工作内存中来，然后在自己的工作内存中修改共享变量的值，最后把修改完成的共享变量重新写到主内存中去。
在这个过程中可能会存在一些问题，**当A线程，从主物理内存中读取共享变量x 的值，并在自己的工作内存中修改了 变量x 的值，但还没有写到主物理内存中去。此时B线程 ，也从主物理内存中读取，但它读取到的值是 x之前的值。**这就是由于可见性导致的问题

1. 代码演示

public class TestVolatile {

	public static void main(String[] args) {
		ThreadDemo td = new ThreadDemo();
		new Thread(td).start();
		
		while(true){
			if(td.isFlag()){
				System.out.println("------------------");
				break;
			}
		}
		
	}

}

class ThreadDemo implements Runnable {
  // private volatile boolean flag = false;
	private boolean flag = false;

	@Override
	public void run() {
		// 防止这个线程 先执行 flag = true
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
		}
		flag = true;
		System.out.println("flag=" + isFlag());

	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}

}

执行上面代码，结果如下：
我们发现程序一直没有结束运行，尽管在工作线程中，flag 的值已经改为 true,但main线程一直不知道。下面我们给flag 加上 volatile 关键字，在执行下。
可以看到程序很快执行完毕。这里也就证明 volatile 保证了变量的可见性！

3.原子性理解

1.原子性的理解

即不可分割的最小单元体，在程序中体现就是：在程序中如果某部分代码，要么不执行，要么都执行，具有这种性质的代码块，我们可以称它具有原子性。

从 java 字节码层面解释 i++ 为啥不是原子性的.。
这里我们以下图为例
1. 先获取到 integer 的值
2. 将int类型常量1压入栈
3. 执行int类型加法 （2.3这两步，实际上是对integer做了加一操作)
4. 把计算成功的值在赋给 integer

在上述过程中，可能会存在其他线程抢断资源的情况，所以说 i++不是原子性的。

2. 演示变量加了 volatile 是不是满足原子性

public static void main(String[] args) {
//		TestVisibility();

		// 演示原子性
		TestAtomic target = new TestAtomic();
		for (int i = 0; i < 10; i++) {

			new Thread(target).start();
		}
		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(target.getInteger());
		
	}
class  TestAtomic implements Runnable{

	private  int integer = 0;

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			add();
		}
	}

	private  void add() {
		integer++;
	}

	public   Integer getInteger() {
		return integer;
	}
}

首先看下不加 volatile 的情况：如果是满足原子性，它的结果一定是 1000
多执行几次 每次执行结果都不一样。那我们加上 volatile 关键字再看一看

// 原子性
class  TestAtomic implements Runnable{

	private volatile int integer = 0;

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			add();
		}
	}

	private  void add() {
		integer++;
	}

	public   Integer getInteger() {
		return integer;
	}
}

这里把上面main 方法循环改为 100 次，这样更容易看出效果
发现结果还是不准确的 ： 即volatile 无法保证变量的原子性。

4. 指令重排

1. 有序性

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

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

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

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

2.指令重排案例

案例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：
### 3.指令重排理解

3.使用案列

单例模式 ---- 双重校验锁

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

为什么这里要加 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实例未必完成初始化,也就造成了线程安全问题.