Java在面对跨平台问题时，重要的一项就是解决硬件和操作系统内存之间的访问。
简要工作逻辑如下图：
cpu的处理速度远快于内存的读写速度，因此Java采用高速缓存建立其桥梁。
其中protocal协议是为了保证多个进程访问cpu主内存时，多个缓存与主内存数据一致性。
当线程需要使用变量数据时，需要从主内存中拷贝一个副本到自己的缓存中，线程来操作这个副本数据，这个缓存也被称作工作内存。
线程修改完数据后重新写入主内存，并更新数据。
思考：多个线程修改主内存的同一个数据，t1在操作备份数据时，别的线程能否中断或挂起t1的执行？t1先写入主内存后，t2,t3中的备份数据怎么办？同一线程中，操作顺序是固定的吗？
内存模型的三大特性
1、原子性
原子性即指在一个操作中，不能被其他操作中断，类似数据库事务的原子性，一个操作就是一个原子操作，保证了线程的安全和数据可靠。
Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作，如上图2。他们的操作就是原子性的。
需要注意的是，没有被volatile修饰的64位数据，会被分2次32位操作，操作一半时可能被其他线程读取，造成结果错误。
示例：1000 个线程同时对num 执行自增操作的结果。
class MyData{
private int num = 0;
public void add(){
num++;
}
public int getNum() {
return num;
}
}
public class Test04 {
public static void main(String[] args) throws InterruptedException {
final int totalNum = 1000;
MyData myData = new MyData();
CountDownLatch count = new CountDownLatch(totalNum);
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < totalNum; i++) {
executor.execute(() -> {
myData.add();
count.countDown();
});
}
count.await();
executor.shutdown();
System.out.println(myData.getNum());
}
}
980
结果为：980<1000，数据不安全。如一个线程执行自增过程中，另一个线程也执行了自增，两个线程同时写入了主内存。解决办法如下
1.1 原子类(Atomic)
使用AtomicInteger类型可以保证多线程下执行的原子性。
修改原来的代码，将num改为AtomicInteger类型数据。
class MyData{
private AtomicInteger num = new AtomicInteger();
public void add(){
num.incrementAndGet();
}
public int getNum() {
return num.get();
}
}
...
1000
1.2 互斥锁(synchronized)
当然，解决线程访问冲突问题，同步锁永远是最直接的方法。但阻塞比较消耗性能，非必要不推荐。
2、可见性
先看代码：
class MyData2{
volatile int num2 = 0;
public void addTo60(){
this.num2 = 100;
}
}
public class Test02 {
public static void main(String[] args) {
MyData2 myData = new MyData2();
new Thread(() -> {
System.out.println(Thread.currentThread().getName()+" --- 原数据 = "+myData.num2);
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
myData.addTo60();
System.out.println(Thread.currentThread().getName()+" --- 修改后数据 = "+myData.num2);
},"myThread01").start();
while (myData.num2 == 0){
// 当num修改时，等待结束
}
System.out.println(Thread.currentThread().getName()+" --- 主线程 = "+myData.num2);
}
}
运行效果图：
线程一直处于阻塞状态，卡在while中，而myThread01打印出num=60。这是因为，myThread01在修改前，主线程已进入while(1)循环，num改变后主线并不知道数据已经被修改。由此引入可见性的概念。
2.1 可见性
当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。
Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。
2.2 实现方式
- volatile
- synchronized
- final，前提：不发生this逃逸。深入理解Java中的逃逸分析
上述代码中，只需将num2类型加volatile即可实现可见性。
volatile int num2 = 0;
myThread01 --- 原数据 = 0
myThread01 --- 修改后数据 = 100
main --- 主线程 = 100
3、有序性
有序性是指在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的。
无序的因为是指令重排序，编译器的一种优化方式。单线程条件下可以提高代码效率，保证了最终执行结果个代码执行顺序的执行结果一直。但却会影响到多线程并发执行的正确性。
重排序是需考虑到数据之间的依赖性。
3.1 解决方式
- volatile
- synchronized
