简单介绍一下JMM

在讲Java内存模型的时候，我们先来了解一下CPU与硬盘的一个关系。

我们都知道CPU是中央处理器，可以非常快速的计算，但是IO却是十分耗费时间的操作。你可以这样理解，我计算1+1可能只要1ms，但是我这个1要在硬盘里面读取的话就需要1s了，那么我这个操作就需要1s（近似）。那么实际上CPU使用情况仅仅使用了1ms，但是反馈给用户的结果却是1s。这是很离谱的操作。为了解决这种情况，计算机有一个高速缓存（Cache），我们先把文件里的1先读到缓存里面，在CPU要用的时候，直接往缓存里面拿数据，那么这样的效率将会快很多。

我们先来理解一下这种架构：

那么我理解的Java内存模型其实和这个差不多。我们程序运行的时候，定义了一个Integer对象i，是放在堆里面的。这里的堆就相当于我们的主内存，我们要对这个对象进行修改的时候，我们首先要把这个对象先往工作内存里面拷贝一份，然后我们在修改这个对象的时候，再通过线程去做一个修改，修改之后把这个对象的值写回主存。

那为什么会发生线程不安全的现象呢？

我们假设要做这样一个事情：

• 线程A要做 i+=2；
• 线程B要做i+=3；

主存	线程A	线程B
初始值 i 为 1
	拷贝一份进入A工作内存，i为1
	做加法操作 i += 2，此时i为3
		拷贝一份进入B工作内存，i为1
		做加法操作i += 3，此时i为4
i 为3	写回主存
i 为 4		写回主存

 

大家可以看到了吧，线程不安全就在于这个把值从主存拷贝回工作内存，做完修改之后再写回主存的这段时间，如果有另外一个线程对同一个值进行操作的话，就会出现线程不安全的现象。

为什么i++不是线程安全的操作？

看完上面的过程，大家应该有所明白了，是先把值取出来，再赋值，再写回

那么我们现在知道了线程对一个对象的操作的一些大概的过程，那么再JVM层面定义了8种操作来描述这个操作过程

1. lock 作用于主存的变量，把主存的一个标量标识为一条线程独占的状态
2. unlock 作用于主存的变量，把主存的一个变量从锁定状态释放掉
3. read 作用于主存的变量，把主存中变量的值拷贝一份副本传输到线程的工作内存中
4. load 作用于工作内存的变量，把read进工作内存的变量存放在线程的工作内存中
5. use 作用于工作内存的标量，把一个值传递给执行引擎CPU
6. assign 作用域工作内存的变量，把从CPU操作完的值赋值给工作内存的变量
7. store 作用于工作内存的变量，把工作内存的变量传输到主存中
8. write 作用域主存的变量，把store传输到主存中的变量赋值到主存变量中

JMM还定义了对应于这8中操作有一下规则：

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

volatile关键字作用：

1. 对于一个变量的修改，对于其他线程是立即得知的
2. 禁止指令重排

volatile关键字修饰的变量只能保证可见性，不能保证原子性。

这也是因为对于变量的修改来说，对于其他线程是立即得知的，但是对于变量操作的时候，可能会发生有线程对变量进行了修改，而对于操作的变量来说还是旧值，在这个时间内，可能回发生线程不安全的现象。

Java内存模型要求lock、unlock、read、load、assign、use、store、write这八种操作都具有原子性，但是对于64位的数据类型（long和double），在模型中特别定义了一条宽松的规定：允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行，即允许虚拟机实现自行选择是否要保证64位数据类型的load、store、read和write这四个操作的原子性，这就是所谓的“long和double的非原子性协定”

Java并发三特性：原子性、可见性、有序性

先行发生原则

1. 程序次序规则（Program Order Rule）：在一个线程内，按照控制流顺序，书写在前面的操作先行发生于书写在后面的操作。注意，这里说的是控制流顺序而不是程序代码顺序，因为要考虑分支、循环等结构
2. 管程锁定规则（Monitor Lock Rule）：一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须强调的是“同一个锁”，而“后面”是指时间上的先后
3. volatile变量规则（Volatile Variable Rule）：对一个volatile变量的写操作先行发生于后面对这个变量的读操作，这里的“后面”同样是指时间上的先后
4. 线程启动规则（Thread Start Rule）：Thread对象的start()方法先行发生于此线程的每一个动作
5. 线程终止规则（Thread Termination Rule）：线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过Thread::join()方法是否结束、Thread::isAlive()的返回值等手段检测线程是否已经终止执行
6. 线程中断规则（Thread Interruption Rule）：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread::interrupted()方法检测到是否有中断发生
7. 对象终结规则（Finalizer Rule）：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始
8. 传递性（Transitivity）：如果操作A先行发生于操作B，操作B先行发生于操作C，那就可以得出操作A先行发生于操作C的结论