第十二章——Java内存模型与线程_不允许一个线程丢弃它最近的 assign 操作-CSDN博客

这一章将了解虚拟机Java内存模型的结构及操作；原子性、可见性、有序性在Java内存模型中的体现；介绍了先行发生原则的规则及使用，了解线程在Java中是如何实现的

硬件的效率与一致性

硬件的多线程问题是什么呢？现在的CPU速度很快，但是内存的读写速度很慢，所以CPU和内存之间加了一些高速读写的内存。每个CPU都有自己的高速内存，如果多个CPU同时处理同一块主内存区域，就有可能各个CPU放在各自的高速内存中的数据不一样，这个时候主内存应该听谁的呢？于是规定了一些协议，说明了这种时候怎么办。

Java内存模型

和硬件上多个CPU的情况类似，Java虚拟机也有主工作内存和属于各个线程的工作内存（这个内存划分和刚开始那章讲的内存划分不是一个层面的）。如果工作内存要用主内存中的变量，那么它就要拷贝一份到自己的内存。就算是volatile变量也一样。而且不同的工作内存之间不能直接访问，必须通过主内存。

1. 内存间交互操作

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

Java内存模型还规定了在执行上述八种基本操作时必须满足如下规则：

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

2. 对于volatile型变量的特殊规则

可见性，volatile变量在某个线程修改之后，其它的线程很快就会知道这件事，而普通的变量是做不到这一点的。虽然很快，但是也需要一定的时间（需要store、write、read、load等一系列操作才行，所以用它的时候要注意，并不是一般意义上的一个锁，强调对其它线程的可见性），这是java虚拟机最轻量级的同步机制。
禁止指令重排序优化，程序执行的时候是有指令重排这个机制的，为了提高效率嘛。指令重排只能保证同一个线程里面，你用到这个变量的时候这个变量的结果是正确的。但是不同的线程中使用同一个变量的时候，发生指令重排就不好了。赋值语句提前被执行的话，会导致使用它的线程产生错误结果。使用volatile可以禁止指令重排（在JDK1.5才完全做到真正的禁止）。
上述的两个volatile变量的特点，是由如下的特殊规则决定的（T表示一个线程，V和W分别表示两个volatile变量，这个规则书上有个比较精确的描述，我就大概谢谢他是啥意思吧）：

线程每次使用volatile变量之前（use前一条必须是load，load后一条必须是use），必须从主内存刷新最新的值。
线程每次修改完volatile之后（store前一条必须是assign，assign后一条必须是store），必须立刻同步到主内存。
保证代码执行顺序与程序顺序相同。（T1:A->F->P，T2:B->G->Q，这些字母表示线程T1和T2分别对V和W的一系列操作，如果A在B前面，那么P就在Q前面，保证这个顺序。PS：A是use或assign，F是load或store，P是read和write）。

3. 对于long和double型变量的特殊规则

Java内存模型要求八个基本操作都要有原子性，但是对于64位数据类型的read、load、store、write四个操作可以不保证原子性。规范允许虚拟机这么做，但是又强烈建议把64位数据类型的读写操作作为原子操作，所以写代码时不需要将用到的long和double专门声明为volatile。

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

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

原子性：由Java内存模型直接保证的原子性变量操作包括read、load、assign、use、store和write这六个，我们大致可以认为基本数据类型的访问读写是具备原子性的（long和double的非原子性协定例外，但是几乎不会发生）。如果需要更大范围的原子性，Java内存模型提供了lock和unlock操作来满足。当然不能直接调用lock和unlock操作，但是虚拟机提供了更高层次的字节码指令monitorenter和monitorexit来隐式的使用这两个操作，反映到Java代码中就是同步块——synchronized关键字，因此在synchronized块之间的操作也具备原子性。
可见性：是指变量被修改之后其他的线程可以看到，volatile变量是通过特殊的规则（改完必须同步，要读取必须从主内存读取）保证了可见性；synchronized是通过unlock之前必须将变量同步到主内存这条规则保证了可见性；final关键字则是因为常量不变，自然可见了。
有序性：只有一个线程，那自然是有序的（就算有指令重排也是有序的）；但是因为“指令重排”和“工作内存与主内存同步延迟”的原因，导致其它线程观察它时，它是无序的。

以上是并发的三种重要特性，可以注意到，这个synchronized哪里都有，很万能?，但是万能有万能的问题。

5. 先行发生原则

Java语言的“先行发生”原则是Java内存模型中定义的两项操作之间的偏序关系，如果说操作A先行发生于操作B，其实就是说在发生操作B之前，操作A产生的影响能被操作B观察到，“影响”包括修改了内存中共享变量的值、发送了消息、调用了方法等。

Java内存模型下有一些“天然的”先行发生关系，这些先行发生关系无须任何同步器协作就已经存在。如果两个操作之间的关系不在此列，并且无法从下列规则推导出来的话，它们就没有顺序性保障，虚拟机可以对它们进行随意的重排序。

程序次序规则：在一个线程内，按照控制流顺序，书写在前面的操作先行发生于书写在后面的操作。
管程锁定规则：一个unlock操作先行发生于后面（时间上的后面）对同一个锁的lock操作。
volatile变量规则：对一个volatile变量的写操作先行发生于后面（时间上的后面）对这个变量的读操作。
线程启动规则：Thread对象的start方法先行发生于此线程的每一个动作。
线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测。
线程中断规则：对线程interrupt方法的调用先行发生于被中断线程的代码检测到中断时间的发生。
对象终结原则：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始。
传递性：如果操作A先行发生于操作B，操作B先行发生于操作C，那就可以得出操作A先行发生于操作C的结论。

“先行发生原则”和时间上的先后顺序并没有太大的关系，先调用的方法不一定先执行，衡量并发安全问题的时候不要受到时间顺序的干扰，一切必须以先行发生原则为准。

Java与线程

1. 线程的实现

不同的操作系统，对线程的实现是不一样的，主要有三种方式：使用内核线程实现、使用用户线程实现、使用用户线程加轻量级进程混合实现。

使用内核线程实现
直接由操作系统内核支持的线程，由内核来完成线程切换，内核通过操纵调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。

程序一般不会直接去使用内核线程，而是使用内核线程的一种高级接口——轻量级进程（也就是通常意义的线程），每个轻量级进程都由一个内核线程支持，是1:1的关系。

这种线程基于内核线程实现，各种操作需要进行系统调用，要在用户态和内核态来回切换，代价较大，每个线程都要有一个内核线程支持，需要消耗一定的内核资源，因此一个系统支持轻量级进程的数量是有限的。

使用用户线程实现
广义上一个线程只要不是内核线程，就可以认为是用户线程，所以轻量级进程也可以算是用户线程。狭义上讲，用户线程是完全建立在用户空间的线程库上，系统内核不能感知到线程存在。用户线程的建立、同步、销毁和调度完全在用户态中完成，不需要内核的帮助，也就不需要切换到内核态，所以非常快，是一种1:N关系的实现。

这种实现优势是不需要系统内核，劣势也是没有系统内核支持，自己实现比较复杂，“阻塞如何处理”、“多处理器系统如何将线程映射到其他处理器上”这类问题解决起来异常困难，现在很少见了。

混合实现
既存在用户线程，也存在轻量级进程，用户线程还是完全建立在用户空间中，所以线程切换快，没有限制，而且还能使用内核对多线程的支持。是一种M:N的关系，许多Unix系列的操作系统，如Solaris、HP-UX等都提供了这种实现。
Java线程实现
Java在JDK1.2之前是基于名为“绿色线程”的用户线程模型实现的，在JDK1.2中，替换成基于操作系统的原生线程模型来实现。

对Sun JDK来说，Windows和Linux都是一对一的线程模型，一条Java线程就映射到一条轻量级进程中。而Solaris平台中可以同时支持一对一和多对多的线程模型，可以通过虚拟机参数设置。

2. Java线程调度

线程调度是指系统为线程分配处理器使用权的过程，分为协同式线程调度和抢占式线程调度。

协同式线程调度，线程的执行时间有线程本身来控制，线程把自己的工作执行完了要主动通知系统切换到另外一个线程上去。实现简单，没有同步问题，但是线程执行时间不可控，可能会有线程长期占用CPU不让出。
抢占式线程调度，每个线程将由系统来分配执行时间（Java中Thread.yield()可以让出执行时间）。

3. 状态转换

Java语言定义了5种进程状态：

新建：创建后尚未启动。
运行：Runable包含了操作系统线程状态中的Running和Ready。
无期限等待：需要等待其他线程显式的唤醒，否则不会被分配CPU时间。没有Timeout参数的Object.wait方法和Thread.join方法，LockSupport.park()方法。
期限等待：一定时间后会自动唤醒的状态，也不会被分配CPU时间。Thread.sleep方法，设置了Timeout参数的Object.wait方法和Thread.join方法，LockSupport.parkNanos方法，LockSupport.parkUntil方法。
阻塞：进程被阻塞了，“阻塞状态”和“等待状态”的区别是：“阻塞状态”在等待着获取到一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生；而“等待状态”则在等待一段时间或者等待唤醒动作发生。在线程等待进入同步区域的时候会发生阻塞。
结束：已终止线程的状态。