java内存模型
java内存模型试图屏蔽各种硬件和操作系统的内存访问差异，以实现让java在各种平台下对内存的一致性访问。
主内存和工作内存
处理器上的寄存器的读写速度比内存快几个数量级，为了解决这种速度矛盾，我们加入了高速缓存Cache。
加入高速缓存的问题就是：缓存一致性。如果多个缓存共享同一个储存区域，那么多个缓存的数据可能不一致，所以需要一些协议来解决这个问题。
所有的变量都存储在主内存中，每个线程有自己的工作内存，工作内存存储在高速缓存中或者寄存器中，保存了该线程所使用变量的主内存副本拷贝。
线程只能操作自己的工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。
内存间的相互操作
Java内存模型定义了8个操作来完成主内存和工作内存的交互操作。
read：把一个变量的值从主内存传输到工作内存。
load：在read执行之后，把read得到的值放入工作内存的变量副本中
use：把工作内存中的一个变量的值传给执行引擎
assign：把一个从执行引擎接受到的值赋值给工作内存中的变量。
store:把工作内存中的一个变量的值传送到内存中。
write：在store执行之后，把store得到的值放入到主内存变量中。
lock:作用于主内存的变量
unlock
内存模型的三大特性
1.原子性
java内存模型保证了read，load，use，assign，store,write,lock和unlock操作具有原子性。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。
有一个错误认识就是，int 等原子性的类型在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 属于 int 类型变量，1000 个线程对它进行自增操作之后，得到的值为 997 而不是 1000。
为了方便讨论，将内存间的交互操作简化为 3 个：load、assign、store。
下图演示了两个线程同时对 cnt 进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入旧值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。
AtomicInteger 能保证多个线程修改的原子性。
用AtomicInterger代替int就能保证线程的安全性。
package ConcurrentExemple;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class UnsafeExemple {
public class Exemple{
private AtomicInteger cnt=new AtomicInteger();
public void add(){
cnt.incrementAndGet();
}
public int res(){
return cnt.get();
}
}
public static void main(String[]args)throws InterruptedException{
int threadSize=1000;
UnsafeExemple e=new UnsafeExemple();
Exemple exemple=e.new Exemple();
CountDownLatch countDownLatch=new CountDownLatch(threadSize);
ExecutorService executorService= Executors.newCachedThreadPool();
for(int i=0;i<threadSize;i++){
executorService.execute(()->{
exemple.add();
countDownLatch.countDown();
// System.out.println(exemple.res());
}
);
}
countDownLatch.await();
executorService.shutdown();
System.out.println(exemple.res());
}
}
2.可见性
可见性是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。java内存模型是在变量改变值后重新放回主内存，在变量读取前从主内存刷新变量值来实现可见性的。
主要有三种实现可见性的方法：
volatile
synchronized
对一个变量执行unlock操作之前，必须把变量值同步回主内存。
final
被final关键字修饰的字段在构造器中一旦初始化完成，并且没有发生this逃逸（其他线程通过this引用访问到初始化了一半的对象），那么其他线程就能看到final的值。对前面的线程不安全示例中的 cnt 变量使用 volatile 修饰，不能解决线程不安全问题，因为 volatile 并不能保证操作的原子性。
3.有序性
有序性是指：在本线程内观察，所有的操作都是有序的。在一个线程观察另一个线程，所有的操作都是无序的，无序是因为发生了指令重排序。在java内存模型中，允许编译器和处理器对指令进行重排序，重排序不会影响单线程程序的执行，却会影响到多线程并发执行的正确性。volatile关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。也可以通过synchronized来保证有序性，它保证每个时刻只有一个线程在执行。
先行发生原则
前面讲到volatile和synchronized可以用来保证有序性，除此之外，JVM还规定了先行发生原则，让一个操作无需控制就可以先与另一个操作完成。
1.单一线程
在一个线程内，程序前面的操作现行于后面的操作发生。
2.管程锁定规则
一个unlock操作先发生于后面对同一个锁的lock操作
3.volatile变量原则
对于一个volatile变量的写操作，现行发生于后面对这个变量的读操作。
4.线程启动原则
Thread对象的start()方法调用先行发生于此线程的每一个动作。
5.线程加入规则
Thread对象的结束先行发生于join()方法返回。
6.线程中断规则
对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以用interrupted()方法进行检测是否有中断发生。
7.对象终结规则
一个对象的初始化完成（构造函数完成），先行发生于它的finalize()发生。
8.传递性
如果A操作先于B操作发生，B操作先于C操作发生，那么A操作先于C发生。
