目录
1、Java 内存模型 JMM
1、为什么需要JMM
不难发现，虽然原子性问题是由于操作系统层面的线程切换导致的，这个无法避免。
但是导致可见性问题的是缓存，导致有序性问题的是指令重排，那么最直接的方式就是禁用缓存和指令重排，这两个问题就解决了。
但如果JVM把这些优化行为一刀切掉，肯定会影响Java程序的性能，而且普通的程序不涉及到这个问题，留着优化更好。
所以合理的方式是，按需禁用缓存和指令重排。
但是什么时候该禁用，只有程序员知道，所以Java提供了一套禁用缓存和指令重排的方法，由程序员自己去选择使用。
这套方法就是Java内存模型（Java Memory Model，JMM），它是一套规范，规范了 JVM 如何提供按需禁用缓存和编译优化的方法。
具体来说，这些方法包括 volatile、synchronized 和 final 三个关键字，以及六项 Happens-Before 规则。
2、JMM与硬件
它定义了主存、工作内存抽象概念，底层对应着CPU寄存器、缓存、物理内存、CPU指令优化等方面。
- 主存：线程共享的数据
- 工作内存：线程私有的数据
JVM运行程序的实体是线程，而每个线程创建时，JVM都会为其创建一个工作内存（即栈空间），用于存储线程私有的数据。
而Java内存模型中规定，所有变量都存储在主内存。主内存是共享内存区域，所有线程都可以访问。
但线程要操作变量，比如读取、赋值等，必须在工作内存中进行。
首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量。
工作内存中存储着主内存中的变量副本拷贝。
工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信必须通过主内存来完成。
Java线程的实现是基于一对一的线程模型，通过语言级别层面的程序去间接调用系统内核的线程模型。
在使用Java线程时，Java虚拟机内部是转而调用当前操作系统的内核线程来完成任务，内核线程会经过调度，在CPU上运行。
但是，Java内存模型的规范与硬件并不一致，硬件只有寄存器、缓存、内存的概念，并没有主存和工作内存的区别。
所以，JMM规范的，有些数据在主存存储，有些数据在工作内存存储，它们在实际运行时，不一定被实际存放在哪里，可能在缓存，也可能在内存。
3、JMM存在的必要性
JMM可以支撑并发编程的三大特性：
- 原子性：保证指令的执行不会受到线程上下文切换的影响，由各种锁保证
- 可见性：保证指令不会受到CPU缓存影响
- 有序性：保证指令不会受到CPU指令并行优化的影响
4、JMM的实现原理
主要是通过内存屏障(memory barrier)禁止重排序的，JIT即时编译器根据具体的底层体系架构，将这些内存屏障替换成具体的 CPU 指令。
- 对于编译器而言，内存屏障将限制它所能做的重排序优化，进而保证有序性
- 而对于处理器而言，内存屏障将会导致缓存的刷新操作，进而保证可见性
比如，对于volatile，编译器将在volatile字段的读写操作前后各插入一些内存屏障
2、volatile
1、volatile的作用
声明一个volatile变量，它的含义是：告诉编译器，对这个变量的读写，不能使用CPU缓存，必须每次从内存中读取或写入。
具体来说：
- 读取时，不采纳工作内存的值，每次都从内存中读取最新的值，放到工作内存中
- 执行时修改工作内存中的值
- 写入时，将工作内存的值直接刷新到内存中
使用方式
语法：可以修饰成员变量、静态成员变量。
局部变量是线程私有的，不用考虑可见性，所以不能加volatile。
volatile可以做到两件事情：禁用指令重排序（保证有序性）、保证变量修改的可见性。
保证可见性
避免线程从自己的高速缓存中查找该变量的值，每次必须从主存中获取该变量的值
虽然效率有损失，但保证了共享变量在多个线程间的可见性。
保证有序性
只能保证单个线程执行时指令的顺序和代码书写顺序一致，不能保证多线程场景下的指令不交错。
2、JDK 1.5版本的升级
在1.5之前，使用volatile修饰只能解决该变量的内存可见性问题，即只能保证这个变量的修改可以立即被其他线程看到。
在1.5之后，JMM对volatile语义进行了增强，增加了一项Happens-Before规则。
这个增强意义重大，1.5 版本的并发工具包（java.util.concurrent）就是靠 volatile 语义来搞定可见性的。
比如这个例子：
假设线程 A 执行 writer() 方法，按照 volatile 语义，会把变量 “v=true” 写入内存；
假设线程 B 执行 reader() 方法，同样按照 volatile 语义，线程 B 会从内存中读取变量 v
如果线程 B 看到 “v == true” 时，那么线程 B 看到的变量 x 是多少呢？
classVolatileExample{intx=0;volatilebooleanv=false; publicvoidwriter(){x=42;v=true;} publicvoidreader(){if(v==true){// 这里x会是多少呢？}}}
在1.5版本之前，x可能是42，也可能是0。因为x并没有被volatile修饰，线程A对x的修改不一定能被线程B看到
在1.5版本之后，x一定是42，因为有两条Happens-Before规则：volatile变量规则+传递性规则：
- x = 42 对 写变量v = true 可见，规则是程序的顺序性
- 写变量v = true 对 读变量v = true 可见，规则是volatile变量
- 由于传递性，所以x = 42对读变量v = true可见
- 也就是说，只要v = true，那么线程A设置的x = 42对线程B是可见的，所以此处x一定是42
3、volatile 与线程安全
一个变量用volatile修饰，不能保证该变量的操作是原子的。
- volatile用于，一个线程修改变量，其他线程读取变量的场景，这样读取变量的线程就能够获取最新值。
- volatile也可以保证单线程下的指令不发生重排。但是不能解决多个线程修改共享变量时的指令交错问题
4、volatile的原理
volatile是通过内存屏障实现的。内存屏障是一个CPU指令，可以用在两个操作之间。（比如读读之间、读写之间、写写之间）
做法：
- 对volatile变量的写指令之后会加上写屏障
- 对volatile变量的读指令之前会加上读屏障
如何保证可见性
- 写屏障之前的，对于变量的写操作，都会立即同步到主存中。
- 读屏障之后的，对变量的读操作，会从主存中读取最新的数据。
如何保证有序性
指令重排时：
- 写屏障之前的代码不会排在写屏障之后。
- 读屏障之后的代码不会排在读屏障之前。
这样就保证了读、写操作对于其他代码的正确顺序。
注意，内存屏障只能保证单个线程执行时指令的顺序，不能保证多线程场景下的指令不交错。
5、synchronized和volatile的区别
它们是互补的，而不是对立的。
- volatile只能修饰变量，synchronized可以修饰代码块和方法
- volatile能保证变量的可见性，但不保证变量操作的原子性。synchronized可以保证它范围内的可见性和原子性。
- volatile关键字主要的作用是，解决共享变量在多个线程之间的可见性。synchronized主要的作用是，解决多个线程在访问共享资源时的同步性。
3、Happens-Before 规则
Happens-Before 的语义是一种因果关系。在现实世界里，如果 A 事件是导致 B 事件的起因，那么 A 事件一定是先于（Happens-Before）B 事件发生的，这个就是 Happens-Before 语义的现实理解。
Happens-Before的本质：前一个事件的结果对后续事件是可见的，不管两个事件是否处于一个线程内。
具体的原理就是禁用缓存，保证可见性。
这些规则约束了编译器的优化行为，虽允许编译器优化，但是要求编译器优化后一定遵守 Happens-Before 规则。
Happens-Before 规则一共有七个规则，一个特性，都是关于可见性的：
1、程序次序规则
这条规则是指在一个线程中，按照程序顺序，前面的操作 Happens-Before 于后续的任意操作。
即单线程中，程序前面对某个变量的修改一定是对后续操作可见的。单线程中没有有序性问题，就是这条规则保证的。
编译器在满足这条规则的前提下，可以随意进行重排优化。
2、volatile 变量规则
这条规则是指对一个 volatile 变量的写操作， Happens-Before 于后续对这个 volatile 变量的读操作。
3、管程中锁的规则
这条规则是指，对一个锁的解锁操作 Happens-Before 于后续对这个锁的加锁操作。
synchronized 是 Java 里对管程的实现，管程中的锁在 Java 里是隐式实现的，在进入同步块之前，会自动加锁，而在代码块执行完会自动释放锁，加锁以及释放锁都是编译器帮我们实现的。
synchronized(this){//此处自动加锁// x是共享变量,初始值=10if(this.x<12){this.x=12;}}//此处自动解锁
可以这样理解：
- 假设 x 的初始值是 10
- 线程 A 执行完代码块后 x 的值会变成 12（执行完自动释放锁）
- 线程 B 进入代码块时，能够看到线程 A 对 x 的写操作，也就是线程 B 能够看到 x==12。
这条规则搭配传递性，就可以得出：前一个线程在临界区修改的共享变量（该操作在解锁之前），对后续进入临界区（该操作在加锁之后）的线程是可见的。
做法是，在解锁的时候，JVM需要强制刷新缓存，使得当前线程所修改的内存对其他线程可见。
4、线程 start() 规则
这条规则是指，主线程 A 启动子线程 B 后，子线程 B 能够看到主线程在启动子线程 B 前的操作
也就是说，在线程start之前的所有操作，对线程都是可见的。
换句话说就是，如果线程 A 调用线程 B 的 start() 方法（即在线程 A 中启动线程 B），那么该 start() 操作 Happens-Before 于线程 B 中的任意操作。
ThreadB=newThread(()->{// 主线程调用B.start()之前// 所有对共享变量的修改，此处皆可见// 此例中，var==77});// 此处对共享变量var修改var=77;// 主线程启动子线程B.start();
5、线程 join() 规则
这条规则是指，主线程 A 等待子线程 B 完成（主线程 A 通过调用子线程 B 的 join() 方法实现），当子线程 B 完成后（主线程 A 中 join() 方法返回），主线程能够看到子线程对共享变量的操作。
也就是说，如果在线程 A 中，调用线程 B 的 join() 并成功返回，那么线程 B 中的任意操作 Happens-Before 于该 join() 操作的返回。
6、线程中断规则
对线程interrupt()方法的调用，对被中断线程是可见的。
也就是说，线程随时可以通过Thread.interrupted()方法检测到是否有中断发生。
7、对象终结规则
一个对象的初始化完成（构造函数执行结束），对它的finalize()方法是可见的。
8、传递性
这条规则是指如果 A Happens-Before B，且 B Happens-Before C，那么 A Happens-Before C。
这条规则对1.5之后的volatile语义做了增强。
4、final
1、final的作用
和volatile相反，final的作用是告诉编译器：这个变量生而不变，可以全力优化
2、final的原理
初始化赋值时：赋值是通过putfield指令实现的，这条指令后面加了写屏障，保证其他线程能正确读到初始化后的值
final修饰的成员变量会在编译期被复制到其他类中，而不是到类中读取，能提高效率。
288
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
