java volatile关键字

对volatile用法一直懵懵懂懂的,网上关于volatile介绍比较多且杂,为此查阅一些资料进行简单的总结,便于理解

理解volatile关键字,我们先了解计算机的发展史,计算机CPU和内存的交互是最频繁的，内存是我们的高速缓存区。而刚开始用户磁盘和CPU进行交互，CPU运转速度越来越快，磁盘远远跟不上CPU的读写速度，才设计了内存，但是随着CPU的发展，内存的读写速度也远远跟不上CPU的读写速度，因此，为了解决这一矛盾，CPU厂商在每颗CPU上加入了高速缓存，用来缓解这种症状，因此，现在CPU同内存交互就变成了下面的样子

 

单核CPU的性能不可能无限制的增长，要想很多的提升新能，需要多个处理器协同工作。 基于高速缓存的存储交互很好的解决了处理器与内存之间的矛盾，也引入了新的问题：缓存一致性问题。在多处理器系统中，每个处理器有自己的高速缓存，而他们又共享同一块内存（下文成主存，main memory 主要内存），当多个处理器运算都涉及到同一块内存区域的时候，就有可能发生缓存不一致的现象。为了解决这一问题，需要各个处理器运行时都遵循一些协议，在运行时需要用这些协议保证数据的一致性。

缓存一致性协议中最出名的就是Intel 的MESI协议，MESI协议保证了每个缓存中使用的共享变量的副本是一致的。它核心的思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存设置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中该变量是无效状态，那么它就会从内存重新读取

Java内存模型

Java的内存模型和上面的结构还是挺相似的，此时在看工作内存和主内存关系，从逻辑上，高速缓存对应工作内存，每个线程分配到CPU时间片时，独自享有高速缓存的使用能力。主内存对应存储的物理内存。

 

Volatile的作用

volatile可以保证可见性，有序性，但不能保证原子性

可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值

假如说有2个线程对一个变量data进行操作，线程先会把主内存中的值复制到工作内存中，这样做的原因和上面提到的高速缓存类似，提高效率

但这样会引起新的问题,如果线程线程A把data数据修改为1,而主内存和线程B的工作内存还为0,此时就可能出现java并发编程可见性问题 

 例如如下例子:

package com.example.test;

import java.util.concurrent.TimeUnit;

import com.example.test.utils.LogUtils;

public class VolatileDemo {
	private static boolean flag = false;

	public static void main(String[] args) {
		Thread threadB = new Thread(new Runnable() {

			@Override
			public void run() {
				while (!flag) {

				}
				LogUtils.e("threadB end");
			}
		});
		threadB.start();

		try {
			// 设置时间单位,内部实际调用还是Thread.sleep(毫秒),
			TimeUnit.SECONDS.sleep(1);
		} catch (Exception e) {
			e.printStackTrace();
		}

		Thread threadA = new Thread(new Runnable() {

			@Override
			public void run() {
				flag = true;
				LogUtils.e("ThreadA end");
			}
		});
		threadA.start();
	}
}

运行结果:

如果将flag修改为

private static volatile boolean flag = false;

运行结果为:

线程B立即能感知到,输出结果为:

 

它的内部实现原理:

1:线程A将工作内存的data更改后，强制将data值刷回主内存

2:如果线程B的工作内存中有data变量的缓存时，会强制让这个data变量缓存失效

3:当线程B需要读取data变量的值时，先从工作内存中读，发现已经过期，就会从主内存中加载data变量的最新值了

有序性

有序性即程序执行的顺序按照代码的先后顺序执行

 

上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序

指令重排序:

处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。上面程序执行过程中,顺序1和顺序2调换,不会影响执行结果的

但是有依赖性的的语句不会重排序

 

执行顺序只能为A-B-C或者 B-A-C,因为C对A有依赖关系,C对B也存在依赖关系,最终执行时不会发生C在A或者B前执行

虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢?如下例子由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。

从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性

 当写双重检测锁定版本的单例模式时，就要用到volatile来保证可见性

原子性:

原子性即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行 

package com.example.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import com.example.test.utils.LogUtils;

public class VolatileDemo {
	private static volatile int inc = 0;

	public static void main(String[] args) {
		// 新建一个线程池
		ExecutorService service = Executors.newCachedThreadPool();
		for (int i = 0; i < 5; i++) {
			service.execute(new Runnable() {

				@Override
				public void run() {
					for (int i = 0; i < 1000; i++) {
						inc++;
					}
				}
			});
		}
		// 关闭线程池
		service.shutdown();
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		LogUtils.e("inc:" + inc);
	}
}

运行结果

可能有的朋友就会有疑问,上面是对变量inc进行自增操作，由于volatile保证了可见性，那么在每个线程中对inc自增完之后，在其他线程中都能看到修改后的值啊，所以有5个线程分别进行了1000次操作，那么最终inc的值应该是1000*5=5000。 

 

自增操作并不是原子性的,它会分三步操作的,读取,赋值,在写入主内存中,在多线程中就可能出现分割操作

假如某个时刻变量inc的值为4，线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了;然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作,所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，也不会导致主存中的值刷新,进行加1操作,将5写入工作内存,最后写入主内存为5

然后线程1接着进行加1操作，由于已经读取了inc的值（inc++，包括3个操作，1.读取inc的值，2.进行加1操作，3.写入新的值），注意此时在线程1的工作内存中inc的值仍然为4，所以线程1对inc进行加1操作后inc的值为5，然后将5写入工作内存，最后写入主存

 

那么两个线程分别进行了一次自增操作后，inc只增加了1。

根源就在这里，自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。

解决方案：可以通过synchronized或lock，进行加锁，来保证操作的原子性。也可以通过使用AtomicInteger

参考资料

《Java并发编程的艺术》