Java虚拟机内存模型与volatile详解

导读

主内存和工作内存
主内存和工作内存的交互操作
volatile关键字详解
原子性、可见性、有序性
先行发生原则

1.主内存和工作内存

Java的内存模型是用来屏蔽掉各种硬件和系统的差异，以实现Java程序在各种平台下都能够达到一致的内存访问效果。它的主要目标是定义程序各个变量的访问规则，即在虚拟机中变量读写的一个过程。此处说的变量包括了实例字段、静态字段和构成数组对象的元素，但不包括局部变量与方法参数，后者是线程私有的，不会被共享，自然就不会存在多线程同时访问造成的并发问题。

Java内存模型中内存分为主内存和工作内存。程序中所有的变量都存储在主内存，而每条线程都有自己的工作内存，工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间也无法直接访问对方工作内存中的变量，线程间的变量值的传递均需要通过主内存来完成。

线程、主内存、工作内存的交互关系如下图所示：
Java虚拟机内存模型与volatile详解

需要注意的是Java内存模型中的主内存和工作内存跟虚拟机内存区域中的堆、栈、方法区不是同一层次的内存划分，如果两者一定要勉强对应起来，主内存主要对应于Java堆内存中的对象实例，而工作内存则对应于虚拟机栈中的部分区域。

2 内存间的交互操作

在Java的内存模型中定义了8种操作来完成主内存和工作内存中的交互操作，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存的。虚拟机实现时必须保证下面提到的每一种操作都是原子级的，不可再分的。
Java虚拟机内存模型与volatile详解

lock（锁定）:作用于主内存的变量，它把一个变量标识为一条线程独占的状态。
unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才能被其他线程锁定
read（读取）：作用于主内存中，它把一个变量的值从主内存传输到线程的工作内存，以便随后的load操作
load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放在工作内存的变量副本中。
use（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，它把一个从执行引擎收到的值赋值给工作内存的变量，每当遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，它把工作内存中的一个变量的值传送到主内存中，以便随后的write操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中得到的变量值放入主内存变量中。

如果要把一个变量从主内存复制到工作内存，那就要顺序的执行read和load操作，如果要把变量从工作内存同步回主内存，则需要顺序执行store和write操作。Java内存模型中只要求上述两个操作必须按顺序执行，而没有保证是连续执行。也就是说read与load之间、store和write之间是可以插入其他指令的。如对主内存中的变量a、b进行访问时，一种可能出现的顺序是：read a 、read b、load b、load a。

在Java内存模型中规定了执行上述8中操作时需要满足的规则：

不允许read和load、store和write操作之一单独出现，即不允许一个变量从主内存读取了但是工作内存不接受，或者从工作内存发起回写了但是主内存不接受的情况。
不允许一个线程丢弃它的最近的assign操作，即变量在工作内存中修改了必须把该变化同步到主内存。
如果一个变量在工作内存中没有发生任何变化（没有发生过任何的assign操作），不允许把数据从工作内存同步到主内存。
一个新的变量只能在主内存中产生，不允许在工作内存中使用一个未被初始化的变量。
一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被一条线程重复执行多次，多次执行lock操作后，只有执行相同次数的unlock操作，变量才会被解锁
如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作初始化变量的值
如果一个变量事先没有被lock操作锁定，那就不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定的变量
对一个变量执行unlock操作之前，必须先把此变量同步回主内存中。

3.volatile关键字

关键字volatile可以说是Java虚拟机提供的最轻量级的同步机制。当一个变量被volatile关键字修饰以后，那么此变量将具备两个特性，第一是保证此变量对所有线程的可见性，这里的“可见性”是指当一条线程修改了这个变量的值，修改后的值对于其他线程来说是可以立即得知的。而普通变量不能做到这一点，普通变量的值在线程间传递，必须通过主内存来完成。

虽然说被Volatile关键字修饰的变量对所有线程是立即可见的，但并不是所有基于volatile变量的运算在多线程的环境下是安全。我们可以通过一个简单的演示来说明原因。

public class VolatileTest{
	
    private static final int THREAD_COUNT = 10;
	
	private static volatile int race=0;
	
	public static void main(String[] args){
	
	   Thread[] threads = new Thread[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
					race++;
					System.out.println(race);
                }
            });
            threads[i].start();
        }
	}
}

这段代码发起了10个线程对race变量进行自增操作，预期的结果是顺序的打印出1到10,在运行这段代码后输出结果如下所示：

D:\javac>java VolatileTest
2
6
8
5
4
3
2
10
9
7

而且会发现每次运行程序，输出的结果都不一样。问题就出在race++这行代码上，在每次执行自增计算的时候，虚拟机指令把race的值取到操作数栈顶，volatile关键字保证了每次取到的值都是正确的，当程序在执行计算的时候，其他的线程可能已经把race的值加大了，而在操作栈顶的值就变成了过期的数字，当计算结束以后就可能把较小的race的值同步回主内存中，所以就会造成计算结果错乱的现象。通过这个例子可以证明一点volatile关键字并不能保证变量的原子操作，因此volatile关键字在不符合以下两条规则的运算场景中，我们仍然要通过加锁来保证原子性。

运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值。
变量不需要与其他的状态变量共同参与不变约束。

使用volatile变量的第二个语义是禁止指令重排序，普通的变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。因为在一个线程的方法执行过程中无法感知到这点。而被volatile关键字修饰的变量将具备以下几个特点：

在工作内存中每次使用变量必须先从主内存刷新最新的值，用于保证能看见其他线程对变量所做的修改后的值。
在工作内存中每次修改变量的值以后必须立刻同步回主内存，用于保证其他线程能够看到自己对变量所做的修改。
被volatile关键字修饰的变量不会被指令重排序优化，保证代码的执行顺序和程序的顺序相同。

4.原子性、可见性、有序性

Java内存模型是围绕着在并发过程中如何处理原子性、可见性、有序性这3个特征建立起来的。

4.1 原子性

所谓的原子性就是不会被虚拟机多线程调度机制干扰的操作，这种操作一旦开始就会运行到结束。通过上面的内容我们了解到工作内存和本地内存进行交互的8种操作，除了lock和unlock操作以外剩余的六种操作都是由Java内存模型来保证的变量的原子性操作，我们大致上可以认为基本数据类型的访问和读写是具备原子性的。

Java内存模型中提供的lock和unlock操作，可以提供更大范围的原子性操作，尽管虚拟机并没有把lock和unlock操作直接开放给用户使用，但是却提供了更高层次的字节码指令，反应到Java代码中就是同步块—synchronized关键字，因此在synchronized块之间的操作也具备原子性。

4.2 可见性

可见性是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。Java内存模型中是通过变量修改后同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现的。无论是普通的变量还是被volatile关键字修饰的变量都是如此，它们的区别是：volatile的特殊规则保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。因此，可以说volatile关键字保证了多线程操作时变量的可见性，而普通变量则不能保证这一点。

除了volatile关键字以外，Java中还有synchronized和final关键字也能实现变量的可见性。synchronized的可见性是由“对一个变量在执行unlock操作之前，必须先把此变量的值同步回主内存中”这条规则实现的。而final关键字的可见性是指：被final修饰的字段在构造器中一旦初始化完成，并且构造器没有把“this”的引用传递出去，那在其他线程中就能看见final字段的值。

4.3 有序性

Java程序中的有序性可以总结为：如果在本线程内观察，所有的操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。前半句是指“线程内表现为串行的语义”，后半句是指“指令重排序”现象和“工作内存和主内存同步延迟”现象。Java语言中提供了synchronized和volatile两个关键字来保证两个线程之间操作的有序性，volatile关键字本身就包含了禁止指令重排序的语义，而synchronized则是由“一个变量在同一时刻只允许一条线程对其进行lock操作”这条规则获得的，这条规则决定了持有同一个锁的两个同步块只能串行地进入。

5.先行发生原则（happens-before）

如果Java内存模型中所有的有序性仅仅依靠volatile和syhchronized关键字来完成，那么有些操作将会变的很繁琐，为了让应用程序免于数据竞争的干扰，在Java内存模型中定义了“先行发生（happen-before）”原则。先行发生是用来描述两个操作的内存可见性的。如果说操作A先行发生于操作B，其实就是说在发生操作B之前，操作A产生的影响能被操作B观察到，“影响”包括修改了内存中共享变量的值、发送了消息、调用了方法等。

在同一个线程中程序执行的先后顺序，也暗含了默认的“happen-before”关系：在程序控制流路径中，靠前的代码操作先行发生于靠后的操作。但这并不意味着后者一定在前者之后执行。如果后者没有观察前者的执行结果，即后者没有数据依赖于前者，那么他们可能被重排序。

除了线程内的happen-before关系外，Java内存模型中还定义了几种线程间的happen-before关系：

管程锁定规则：一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须是同一个锁，而“后面”是指时间上的先后顺序
volatile变量规则：对一个volatile修饰的变量的写操作先行发生于后面对这个变量的读操作
线程启动规则：Thread的start()方法先行发生于此线程的每一个动作
线程终止操作：线程中的所有操作都先行发生于对此线程的终止检测。我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测到线程已经终止操作
线程中断操作：对线程的interrupt()方法的调用先行发生于线程所收到的中断事件（即被中断线程的interruptException异常）
对象终结规则：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始。