volatile原理技术知识整理

volatile是一种轻量且在有限的条件下线程安全技术，它保证修饰的变量的可见性和有序性，但非原子性。相对于synchronize高效，而经常跟synchronize配合使用。

一. Java内存模型

这里主要描述的线程，工做内存，主存的变量的读写关系：

1. 主存存放线程须要操做的变量，但线程并不直接操做主存。
2. 每一个线程读取主存变量都是先拷贝一份到工做内存中，不一样线程工做内存互不干扰。
3. 线程修改了工做内存后，再写回主存中。
4. 每次从主存读写的过程都须要通过8原子性操做。

二. volatile可见性

1. volatile特殊性

(1) 操做use以前必须先执行read和load操做。

(2) 操做assign以后必须执行store和write操做。

由特性性保证了read、load和use的操做连续性，assign、store和write的操做连续性，从而达到工做内存读取前必须刷新主存最新值；工做内存写入后必须同步到主存中。读取的连续性和写入的连续性，看上去像线程直接操做了主存。

扩展： lock和unlock操做并不直接开放给用户使用，而是提供给像Synchronize关键字指定monitorenter和monitorexit隐式使用。关于Synchronize的监听器锁monitor，javac编译后会在做用的方法先后增长monitorenter和monitorexit指令，详细的能够查看Synchronize原理。

2. 代码验证可见性

public class VolatileVisibility {

public static class TestData {
	volatile int num = 0;
	public void updateNum(){
		num = 1;
	}
}

public static void main(String[] args) {
	final TestData testData = new TestData();
	new Thread(new Runnable() {
		
		@Override
		public void run() {
			System.out.println("ChildThread num-->"+testData.num);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			testData.updateNum();
			System.out.println("ChildThread update num-->"+testData.num);
		}
	}).start();
	
	while (testData.num == 0){
     }
	
	System.out.println("MainThread num-->"+testData.num);
  }
}
复制代码

(1) TestData中的num不添加volatile关键字，System.out.println("MainThread num-->"+testData.num);这一句一直不会执行。表示while中的条件testData.num == 0一直为0，子线程修改了num对主线程不起做用。

(2) TestData中的num添加volatile关键字，System.out.println("MainThread num-->"+testData.num);会执行，结果以下。

ChildThread num-->0
ChildThread update num-->1
MainThread num-->1
复制代码

三. volatile非原子性

1. use和assign这两个操做总体上不是一个连续性的原子操做。

volatile自己并不对数据运算处理维持原子性，强调的是读写及时影响主存。

2. 非原子性操做

volatile修饰num，num++；num = num+1；这种就是非原子性操做。

(1) 主存读取num的值；

(2) 进行num++运算；

(3) 将num值写到主存。

像种操做在多线程环境中，use和assign是屡次出现，若是有两个线程中读取到主存的num都是2，且同时执行num++，两个线程的结果都是3，这样就产生了脏数据，再写入主存中都是3。核心num++运算并没保证前后顺序执行。为了保证执行运算的线程顺序，能够选择Synchronize。

3. 代码验证非原子性

public class ValatileAtomic {
public static class TestData {
	volatile int num = 0;
      //synchronized
	public void updateNum(){
		num++;
	}
}

public static void main(String[] args) {
	final TestData testData = new TestData();
	for(int i = 1; i <= 10; i++) {
        new Thread(new Runnable() {
			@Override
			public void run() {
				for (int j = 1; j <= 1000; j++) {
					testData.updateNum();
                }
			}
		}).start();
    }
    
    while (Thread.activeCount() > 2) {
        Thread.yield();
    }
    System.out.println("最终结果：" + testData.num);
  }
}
复制代码

按咱们的意愿10个线程，每一个线程累加线程累加1000，一共是10 * 1000=10000。可是volatile int num = 0; 使用volatile与否都是体现非原子性，运行的结果都比10000小：

最终结果：9701
复制代码

为了实现同步操做，在方法updateNum()前添加关键字synchronize便可：

最终结果：10000
复制代码

四. volatile有序性

1. volatile禁止指令重排

(1) 指令重排：为了提升性能，编译器和和处理器一般会对指令进行指令重排序。

图中的三个重排位置能够调换的，根据系统优化须要进行重排。遵循的原则是单线程重排后的执行结果要与顺序执行结果相同。

(2) 内存屏障指令：volatile在指令之间插入内存屏障，保证按照特定顺序执行和某些变量的可见性。

volatile就是经过内存屏障通知cpu和编译器不作指令重排优化来维持有序性。

2. synchronize串行控制

(1) synchronize无禁止指令重排。

(2) 一个变量在同一时刻只容许一条线程对其进行lock操做，获取对象锁，互斥排他性达到两个同步块串行执行。

五. volatile线程安全适用范围

因为volatile的非原子性缘由，因此它的线程安全是有条件的：

(1) 运算结果不依赖但前置，或者能保证自由一个单一线程修改变量值。

(2) 变量不须要与其余的状态变量共同参与不变的约束。 这两条件描述出自于《深刻理解java虚拟机》。

六. volatile与synchronize配合使用

1. DCL单例代码

public class Singleton {

private volatile static Singleton instance = null;
private Singleton(){
	
}

public static Singleton getInstance(){
	if(instance == null){ // 第①处
		synchronized (Singleton.class) {
			if(instance == null){  // 第②处
				instance = new Singleton();
			}
		}
	}
	return instance;
  }
}
复制代码

2.为何还要使用volatile来修饰

按照上边的写法已经对new Singleton();这个操做进行了synchronize操做，已经保证了多线程只能串行执行这个实例化代码。事实上，synchronize保证了线程执行实例化这段代码是串行的，可是Synchronize并不具有禁止指令重排的特性。

而instance = new Singleton(); 主要作了3件事情：

(1) java虚拟机为对象分配一块内存x。

(2) 在内存x上为对象进行初始化 。

(3) 将内存x的地址赋值给instance 变量。

若是编译器进行重排为：

(1) java虚拟机为对象分配一块内存x。

(2) 将内存x的地址赋值给instance 变量。

(3) 在内存x上为对象进行初始化 。

第一种状况，无volatile修饰：此时，有两个线程执行getInstance()方法，加入线程A进入代码的注释中的第②处，并执行到了重排指令的（2），与其同时线程B恰好代码注释中的第①处的if判断。此时，instance有线程A把内存地址x地址赋值给了instance，那么instance已经不为空只是没有初始化完成，线程B就返回了一个没有完成初始化的instance，最终使用时候会出现空指针的错误。

第二种状况，有volatile修饰：instance由于被volatile的禁止指令重排的特性，那只会安装先初始化对象再赋值给instance这样顺序执行，这样就能保证返回正常的实例化的对象。

七. 小结

1.volatile具备可见性和有序性，不能保证原子性。

2.volatile在特定状况下线程安全，好比自身不作非原子性运算。

3.synchronize经过获取对象锁，保证代码块串行执行，无禁止指令重排能力。

4.DCL单例操做须要volatile和synchronize保证线程安全。