JMM内存模型学习一

概念

java内存模型（Java Memory Model）简称JMM，是一种抽象概念，通过它定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。JMM定义了线程和主内存之间的抽象关系。

内存模型

内存概念

主内存（共享内存）

在java中，所有的实例域、静态域和数组元素都存在堆内存中，堆内存在线程之间共享。这块区域就是共享内存，所有线程都可以访问，因此多个线程对同一变量访问时可能会出现并发问题。

工作内存

工作内存中主要存储本地变量信息，像局部变量、方法定义参数和异常处理器参数（和从主内存中copy出来的副本）。每个线程都有自己私有的工作内存，它是独享的，对其他线程是不可见的，因此工作内存中的数据不存在安全问题。

流程

JVM运行程序实体是线程，每个线程创建时都会创建为其创建一个工作内存（有些地方称为栈空间），用于存储线程的私有数据。而JMM模型归档所有的变量都存储到主内存中，主内存是一个共享内存区域，所有线程都可以访问。
线程对变量的操作（读取、修改）都必须在工作内存中进行。因此首先要把变量从主内存中copy到自己的工作内存，然后对变量进行操作，操作完成后再将变量写回到主内存。工作内存是每个线程的私有内存区域，因此不同的线程之间不能访问对方的工作内存。线程间的通信必须是有主内存来完成的。

交互图

线程之间的通信机制

概念

由于线程的工作内存独享的，对其他线程是不可见的，因此线程之间的通信是通过共享内存来进行的。JMM通过控制主内存与每个线程的工作内存的交互，达到线程间的通信，来提供内存的可见性。

过程

如线程1和线程2之间的通信过程
假设线程1和线程2从主内存读取了共享变量x=0的副本，此时三个内存中的变量x的值都为0。线程1执行时，把将x更新为1，存入自己的工作内存中。当前线程1和线程2需要通信时，线程1首先会把自己工作内存中修改后的x值刷新到主内存中，此时主内存的x值变为1。随后，线程2到主内存中去读取线程A更新后的x值，此时线程2的本地内存的x值也变为1。
简单的来讲，分为下面两步
（1）线程1把它的工作内存中更新过的共享变量副本刷新到主内存中去
（2）线程2到主内存中去读取线程1已更新过得共享变量

JMM的三大概念

JMM是围绕原子性、有序性和可见性来展开的。

原子性

原子性是指一个操作只要开始就不能被中断。即使在多线程环境下，一个线程的一个操作只要开始，就不能被其它线程影响
像 x=1,像这种简单读取或者直接赋值的是 原子性操作
y=x: 是先读取x和y然后赋值给y，不是原子性操作
x++: 这个自增也不是原子操作，它是先读x然后再自增赋值
特别需要注意的是，对于32位的系统，基本类型dubbo和long的读和写操作不是原子性的，dubbo和long是64位的存储单元，对于32位的系统，每次读写是32位的，所以需要两次读才能读取到整个数据。
因此需要并发情况下，需要保证线程安全问题。
如下：
i++自增原子性线程安全问题
对此并发情况下，我们应该如何保证原子性呢？

保证原子操作

1、使用循环CAS实现原子操作
CAS原理：CAS操作需要输入两个值，一个旧值（期望操作前的值）和一个新值（期望值），在操作期间先比较旧值有没有发生变化，如果没有发生变化，才交换新值，发生了变化则不交换。
基本思路：循环进行CAS操作直到成功为止。主要底层使用Unsafe类。
CAS实现原子操作有三个问题：
（1）ABA问题。CAS在操作值得时候需要检查值有没有发生变化，再做决定是否更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS会判定它的值没有发生变化，实际上是发生了变化。解决思路是：加序列号，1A-2B-3A。JDK提供了AtomicStampedReference类解决ABA问题，其中的compareAndSet方法首先检查当前引用是否等于预期的引用，并且检查当前标志是否等于预期标志，如果全部相等就替换
（2）循环时间长开销大。自旋CAS如果长时间的不成功，会给CPU带来非常大的执行开销。
（3）只能保证一个共享变量的原子操作
2、 使用并发包中的一些类提供的原子操作
如果AtomicBoolean、AtomicInteger等用原子方式更新。比如AtomicInteger的原子自增。
3、使用锁机制实现原子操作
锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。其实除了偏量锁外，其它锁都使用了循环CAS。需要注意是加锁效率就会降低很多，所以要尽量降低锁范围。

有序性

有序性是指单个线程内执行代码，我们总是认为代码是按照顺序执行的，但其实在编译成机械指令可能会出现指令重排，重排后会导致实际执行顺序发生变化，但对于本线程中最终执行结果是一致的。但在多线程的情况下就会出现线程安全问题。
如线程A中有三个指令A1->A2-A3，编译后实际执行可能会是A2->A3->A1。
在单线程的情况下是完全没有问题的，因为指令重排的前提是需要保证最终结果的正确。
但是多线程并发的情况下能就会出现问题：
期初a=0,b=0,x=0,y=0
线程A中：a=1->x=b
线程B中：b=1->y=a
按照这种正常语序执行的话，得出结果：x=1,y=1
但是指令重排后
线程A中：x=b->a=1
线程B中：y=a->b=1
可能得出的结果就是x=0,y=0
对此JDK提供了volatile来禁止指令重排保证有序性
举例：双重检测延迟加载单例模式最终版

java中解决有序性并发问题

1、使用volatile禁止指令重排
2、使用锁，使线程串行访问

可见性

可见性是指当一个线程修改了某个共享变量的值，其他线程可以立刻得知这个修改的值。
但是JMM模型中规定，线程对共享变量的操作是线程将共享变量拷贝到自己的工作内存中，然后对共享变量的复制进行操作，再将修改后的值刷新到主内存中。因此可能会存在这种情况，线程A修改了共享变量X的值，还没有刷新到主内存中时，线程B有对共享变量X的值进行了修改，由于线程A的操作对线程B是不可见的，这就会导致可见性的并发问题。
对此JDK提供了volatile来保证其可见性。
机制：

当写一个volatile变量时，JMM会把该线程对应本地内存的共享变量修改的值立刻刷新到主内存中
当读一个volatile变量，JMM会把该线程工作内存的对于变量设置为无效，并且直接从主内存中读取共享变量

锁机制也可以解决一定的可见性（不建议）
原理

锁机制可以保证在同一时间只有一个线程访问共享资源
并在释放前将修改后的值刷新到主内存
有性能问题，并有局限性，必须是在释放才会将值刷新到主内存中，在刷新到主内存之前的读取线程是也是不可见，因为其工作内存中还是旧值。最起码解决不了下面的问题。

举例：
未使用volatile修改

使用volatile修修饰

示例：JMM学习之可见性问题示例和解决办法

指令重排

重排序是指编译器和处理器为了优化程序性能而对指令进行重新排序的一种手段，使机器指令能够更符合CPU的执行特性，最大限度的发挥机器性能。
指令重排需要遵守数据依赖性、as-if-serial语义、happens-before程序顺规则

指令重排序的过程

（1）编译器优化的重排序：编译器在在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
（2）指令级并行的重排序：处理器采用指令级并行技术（ILP）将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变机器指令的执行顺序。
（3）内存系统的重排序：由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是乱序执行

数据依赖性

在单线程中执行的两个操作，如果存在依赖关系就不能进行重排序。
如
写后读: a=1;b=a;
写后写：a=1;a=2;
读后写：a=b;b=1;
这三种情况，一旦发生指令重排其结果就会发生改变，因此不能指令重排。
再如：
a=1;b=1;
a=b;c=d;
这种指令间没有依赖关系的，并且不会影响最终结果的就可以进行指令重排

as-if-serail语义

as-if-serail语义要求：不管怎么重排序，单线程内的执行结果不能改变。所有的环节的重排序都必须遵守as-if-serial语义。as-if-serail要求不能对存在数据依赖关系的操作做重排序。
as-if-serail的保证 程序员无需担心重排会干扰他们

happens-before

内存模型使用happens-before的概念来阐述操作直接的内存可见性。在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么两个操作直接必须要存在happens-before关系。这两个操作可以在 同一个线程内也可以不在同一个程序内
规则：
（1）程序顺序规则：一个线程中的必须保证语义的串行。
如： A happens-before B

 JMM并不要求A一定要在B之前执行。JMM仅要求前一个操作执行的结果对后一个操作可见，且前一个操作按照顺序排在第二个操作之前。
在操作A的执行结果不需要对操作B可见时，且在重排序A和B后的执行结果，与A和B按happens-before顺序执行的结果一致。这种情况下，JMM会认为这种重排序不非法。

（2）监控器锁规则：解锁操作必须发生在后续的同一个锁的加锁之前。
（3）volatile变量规则：对一个volatile写一定发生在后续任意的对这个volatile的读之前。保证可见性
（4）传递性：

1）A happens-before B
2）B happens-before C
那么可以得出
3）A happens-before C

（5）线程启动start规则：如果线程A中执行启动线程B操作ThreadB.start()，那么在启动线程B操作之前对共享变量的修改是对线程B是可见的
（6）join()规则：如果线程A中执行线程B终止ThreadB.join()并成功返回，那么在线程B对共享变量的修改是对线程A可见。