B6. Concurrent 内存模型与线程

【概述】

　　Java 虚拟机规范中试图定义 Java 内存模型（Java Momery Model, JMM）来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各个平台下都能达到一致的内存访问效果。

【主内存与工作内存】

　　Java 内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量（Variables）与 Java 编程中所说的变量有所区别，它包括了实例字段、静态字段和构成数组对象的元素，但不包括局部变量与方法参数，因为后者是线程私有的，不会被共享，自然就不会存在竞争问题。

　　Java 内存模型规定了所有的变量都存储在主内存（Main Memory）中，每条线程都有自己的工作内存（Working Memory），线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递都需要通过主内存来完成，线程、主内存、工作内存三者的交互关系如下图所示：

　　这里所讲的主内存、工作内存与 Java 内存区域中的 Java 堆、栈、方法区等并不是同一个层次的内存划分，这两者基本上是没有关系的，如果两者一定要勉强对应起来，那从变量、主内存、工作内存的定义来看，主内存主要对应于 Java 堆中的对象实例数据部分，而工作内存则对应于虚拟机栈的部分区域。从更低层次上说，主内存就直接对应于物理硬件的内存，而为了获取更好的运行速度，虚拟机可能会让工作内存优先存储于寄存器和高速缓存中，因为程序运行时主要访问读写的是工作内存。

【内存间的交互操作】

　　关于主内存与工作内存之间具体的交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存之类的实现细节，Java 内存模型中定义了以下 8 种操作来完成，虚拟机实现时必须保证下面提及的每一种操作都是原子的、不可再分的。

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

【三大特性】

　　1. 原子性（Atomicity）

　　由 Java 内存模型来直接保证的原子性变量操作包括 read、load、use、assign、store 和 write，可以认为基本数据类型的访问读写是具备原子性的。如果应用场景需要一个更大范围的原子性保证（常见情况），Java 内存模型还提供了 lock 和 unlock 操作来满足这种需求，尽管虚拟机未把 lock 和 unlock 操作直接开放给用户使用，但是却提供了更高层次的字节码指令 monitorenter 和 monitorexit 来隐式地使用这两个操作，这两个字节码指令反映到 Java 代码中就是同步块——synchronized 关键字，因此在 synchronized 块之间的操作也具备原子性。

　　2. 可见性（Visibility）

　　可见性是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。Java 内存模型是通过在变量修改（assign）后将新值同步（store + write）回主内存，在变量读取（use）前从主内存刷新（read + load）变量值到工作内存，依赖主内存为传递媒介的方式来实现可见性的。无论是普通变量还是 volatile 变量都是如此，两者之间的区别是：volatile 的特殊规则保证了新值能立即同步到主内存，即 assign 操作后必须做一次 store + write，以及每次使用读取变量前从主内存刷新，即 use 操作前必须做一次 read + load。因此，可以说 volatile 保证了多线程操作时变量的可见性，而普通变量不能保证这一点。

　　除了 volatile 之外，Java 还有两个关键字能实现可见性，即 synchronized 和 final。synchronized 同步块的可见性是由 “对一个变量执行 unlock 操作之前，必须先把此变量同步回主内存（store + write）” 这条规则获得的。final 关键字的可见性是指：被 final 修饰的字段在构造器中一旦初始化完成，并且构造器没有把 “this” 的引用传递出去，线程无法对该变量进行修改（assign），看到都是同一个值。

　　3. 有序性（Ordering）：

　　Java 程序的有序性可以总结为：如果在本线程内观察，所有的操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。前半句是指 “线程内表现为串行的语义”，后半句是指 “指令重排序” 现象和 “工作内存与主内存同步延迟” 现象。

　　Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 关键字本身就包含了禁止指令重排序的语言，而 synchronized 则是由 “一个变量在同一时刻只允许一条线程对其进行 lock 操作” 这条规则获得的，这条规则决定了持有同一个锁的两个同步块只能串行地进入。

【volatile 为什么不能保证原子性？】

　　例子：使用 volatile 关键字修饰 int 变量 i，初始值为 0，多线程并发执行语句 i++。i++ 包括三个步骤：

　　1). 将主内存的变量 i 同步到工作内存（read + load）；

　　2). 执行引擎对工作内存中的变量 i 进行读取操作（use），然后执行加 1 操作，最后对变量 i 进行赋值操作（assign）；

　　3). 将工作内存的变量 i 刷新回主内存。（store + write）

　　volatile 关键字没有对变量执行 lock 操作，多个线程可能同时执行 use 操作，volatile 保证了进行 use 操作之前必须进行一次 read + load，即可能多个线程都读取到同一个值 0，进行完步骤（2）后都将工作内存中的变量 i 赋值为 1，都将 1 刷新到主内存中，可想而知最后得不到正确的结果。

转载于:https://www.cnblogs.com/zlxyt/p/11082473.html