并发编程--多线程的实现原理

JMM内存模型

JMM：定义了共享内存系统中多个线程去访问内存的一种规范，去屏蔽硬件和操作系统内存访问的差异。它最终实现java程序在各个平台下都能达到一致性内存访问的效果。
JMM的访问规则：

在JMM中定义了八种原子操作，去定义线程访问内存时需要经历的操作。

JMM是一种规范，目的是解决多线程通过共享内存进行通信的时候，去导致本地内存数据不一致的问题。
JMM内存模型是基于物理模型的抽象。

线程之间的通信通过两种方式， 一种通过共享内存的共享变量。第二种通过消息传递的方式。 例如wait/notify. 这种线程之间是没有公共状态的。 它是通过线程之间发送消息。

主内存定义的是jvm上的堆内存。 堆内存是从当前硬件物理内存分配给进程一块内存。

JMM如何解决原子性, 可见性，有序性的问题

volatile /synchronized/final/java.util.concurrent
原子性
synchronized（monitorenter/monitorexit）
可见性
volatile ,synchronized,final
有序性
volatile, synchronized

volatile:轻量级的锁，解决可见性（lock），防止指令重排。
lock指令加了个内存屏障
从CPU层面来了解什么是内存屏障：s有的问题来源都是起源于硬件高速缓存，多核心存在的，最终的解决方案也是从底层解决。
屏障l作用： 防止指令之间的重排序， 保证数据的可见性。

store barrier(写屏障-storestore barrier） : 强制所有在storestore内存屏障之前的所有指令先执行，并且发送缓存失效的信号。 所有在storestore内存屏障指令之后的store指令, 必须在storestore内存屏障指令之前的指令执行完之后再执行。同时它还会加载新的数据，去更新它自己的缓存。所以可以通过 storestore barrier 保证数据的可见性。
见下图： 就是store A的指令一定在store B的指令执行之前执行。同时保证store A改变的数据同步到主内存。意味着store B能从主内存拿到最新的值。

load barrier(读屏障） loadload barrier

见下图： 强制在loadload 指令之前的指令它必须要优先执行。意味着load A 和load B无法实现重排序。

full barrier(全屏障， 前面两个的结合）

内存屏障解决的是顺序问题，保证各个指令在执行的时候按照指定顺序执行的。 不能解决缓存一致性问题，缓存一致性问题由缓存锁来解决，MESI协议去完成。

编译器层面如何解决指令重排序问题？
CPU层面不关心， 因为对于Java语言来说，直接打交道的是Java内存模型，它屏蔽了底层硬件的问题和差异。我们只需要
关心Jmm层面怎么去解决指令重排序问题，编译器提供了volatile关键字解决，它可以取消编译器层面上的缓存和重排序问题。
保证编译器编译的时候我们在优化屏障之前的指令不会在 优化屏障之后执行。这就是保证了编译器的优化不会影响到实际的代码执行顺序。
Jmm提供了相应指令：
loadload barrier；load1 loadload load2 load1的指令一定优于load2执行。
storestore barrier；
loadstore barrier；
storeload barrier 通过这些指令保证了 内存可见性问题。

例子:

编译后查看。

有ACC_VOLATILE指令。

再看JVM源代码：

oop.inline.hpp,

调用orderAccess.hpp 的release_store方法

release_store具体的实现是根据不同的操作系统有不同的实现方式。

比如linux_x86的实现 orderAccess_linux_x86_inline.hpp release_store方法

这里面的volatile 是C++的关键词，他是个语言级别的内存屏障，表示这个变量随时可能发生变化，每次使用的时候，必须要从
对应的内存地址读取。 编译器对该操作的变量代码优化。

1. 对每个volatie 写操作的前面插入storestore barrier.
2. 对每个volatie 写后面的操作插入storeload barrier.
3. 对每个volatie 读操作的前面插入loadload barrier.
4. 对每个volatie 读操作的后面插入loadstore barrier.

总结：

  volatile 是干嘛的？ 1： volatile 是对可变对象就行修饰的，可以保证可见性，防止内存重排序。 
                                  2： 它可以去让CPU,有个#lock 指令使得缓存基于CPU的缓存锁和MESI协议去实现一致性。 
                                  3： 防止内存重排序通过内存屏障，

volatile 不能保证原子性。

这四种屏障是用来解决编译器重排序和CPU指令重排序的问题。

loadload(), loadstore() 都是调用acquire(). 这两个定义在Java读之前，在编译器执行阶段，CPU执行阶段, 在acquire之后所有的读写操作不能越过acquire，重排到acquire之前。所以acquire让之后的所有读都具有可见性。

storestore() release定义在Java写之后，在编译器执行阶段，CPU执行阶段, 在release之前所有的读写操作不能越过release，重排到release之后。 所以release之前的所有写操作都会刷新到内存。

storeload 在编译器执行阶段，CPU执行阶段, 在fence之前的任何操作不能重排到屏障之后。