我们无论使用Java还是C，或者别的编程语言，都会遇到并发场景，编写并发程序。所以今天探讨一下，并发场景中遇到的问题，也就是Java的内存模型（JMM）。
并发程序要比串行程序复杂的多，最主要的原因就是在并发程序下，如何保证数据访问的一致性和安全性。因此我们需要在深入的了解并行机制的前提下，再定义一种规则，保证多个线程之间可以有效的、正确的协调工作。这就是JMM的由来。
JMM的关键技术点主要是围绕多线程的原子性、可见性和有序性来建立的，所以我们先从这些概念了解。

@TOC

原子性（atomicity）

什么是原子性？

原子性是指一个操作不可以被中断。即使在多线程中，多个线程一起执行的时候，一旦操作开始，就不会被其他线程干扰。也就是说要么一起执行，要么一起停止失败。
看下面一个例子：

x = 10;     //语句1
y = x;         //语句2
x++;         //语句3
x = x + 1;     //语句4

注意：其实只有语句1是原子性操作，其他三个语句都不是原子性操作。

1. 语句1是直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工作内存中。
2. 语句2实际上包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及将x的值写入工作内存，这2个操作都是原子性操作，但是合起来就不是原子性操作了。
3. 同样的，x++和 x = x+1包括3个操作：读取x的值，进行加1操作，写入新的值
   也就是说，只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

从上面可以看出，Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。

由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

可见性（visibility）

什么是可见性？

可见性是指当一个线程修改了某个共享变量的值，其他线程能否立即知道这个修改后的值。

//线程1执行的代码
int i = 0;
i = 10;
//线程2执行的代码
j = i;

1. 当线程1执行 i =10这句时，会先把i的初始值加载到工作内存中，然后赋值为10，那么在线程1的工作内存当中i的值变为10了，却没有立即写入到主存当中。
2. 此时线程2执行 j = i，它会先去主存读取i的值并加载到线程2的工作内存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.

这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

对于可见性，Java提供了volatile关键字来保证可见性。当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

有序性（ordering）

什么是有序性？

有序性问题可能是三个问题中最难理解的了。对于一个线程的执行代码而言，我们总是习惯性的认为，代码的执行顺序是从前往后的，依次执行的。其实这么理解，也不是完全错误，最起码对于单线程而言的确是这样的，但在并发场景中，程序的执行可能就会乱序。也就是会进行指令重排序。
举个例子：

int i = 0;
boolean flag = false;
i = 1; //语句1
flag = true; //语句2

上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。

从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序（Instruction Reorder）。

什么是指令重排序？

这里简单的介绍下什么是指令重排序。

指令重排序：一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

指令重排序的数据依赖性

那么随之来的一个问题，它会对指令进行重排序，那么是靠的什么来保证最终的程序结果和代码执行的结果一致的呢？

再看个例子：

int a = 10; //语句1
int r = 2; //语句2
a = a + 3; //语句3
r = a*a; //语句4

这个·代码有4个语句，那么可能的执行语句顺序为：

那么有没有可能是：
语句2---》语句1----》语句4---》语句3

答案是没有可能。为什么？

因为处理器在进行重排序时是会考虑指令之间的数据依赖性，如果一个指令Instruction 2必须用到Instruction 1的结果，那么处理器会保证Instruction 1会在Instruction 2之前执行。

虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：

//线程1:
context = loadContext(); //语句1
inited = true; //语句2
//线程2:
while(!inited ){
sleep()
}
doSomethingwithconfig(context);

上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。