摘要

咱们之前解说了JMM模型，以及其引入的必要行，以及JMM与JVM内存模型的比拟和JMM与硬件内存构造的对应关系。

思维导图

本节次要解说思维导图如下：

内容

1、JMM的8大原子操作

1、lock(锁定)：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。
2、unlock(解锁):作用于主内存的变量，它把一个处于锁定状态的变量释放出来，开释后的变量 才能够被其余线程锁定。
3、read(读取):作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以 便随后的load动作应用。
4、load(载入):作用于工作内存的变量，它把read操作从主内存中失去的变量值放入工作内存的 变量正本中。
5、use(应用):作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚 拟时机到一个须要应用变量的值的字节码指令时将会执行这个操作。
6、assign(赋值):作用于工作内存的变量，它把一个从执行引擎接管的值赋给工作内存的变量， 每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
7、store(存储):作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随 后的write操作应用。
8、write(写入):作用于主内存的变量，它把store操作从工作内存中失去的变量的值放入主内存的变量中。

留神：
1、如果须要把变量总主内存赋值给工作内存：read和load必须是间断；read只是把主内存的变量值从主内存加载到工作内存中，而load是真正把工作内存的值放到工作内存的变量正本中。
2、如果须要把变量从工作内存同步回主内存；就须要执行程序执行store跟write操作。store作用于工作内存，将工作内存变量值加载到主内存中，write是将主内存外面的值放入主内存的变量中。

代码实例：

public class VolatileTest2 {     static boolean  flag = false;     public void refresh(){         this.flag = true;         String threadName = Thread.currentThread().getName();         System.out.println("线程: "+threadName+" 批改共享变量flag为"+flag);     }     public void load(){         String threadName = Thread.currentThread().getName();         while (!flag){         }         System.out.println("线程: "+threadName+" 嗅探到flag状态的扭转"+" flag:"+flag);     }     public static void main(String[] args) {         /**          * 创立两个线程          */         VolatileTest2 obj = new VolatileTest2();         Thread thread1 = new Thread(() -> {             obj.refresh();         }, "thread1");         Thread thread2 = new Thread(() -> {             obj.load();         }, "thread2");         thread2.start();         try {             /**              * 确保咱们线程2先执行              */              Thread.sleep(2000);         }catch (Exception e){             e.printStackTrace();         }         thread1.start();     }}

咱们发现下面代码数据后果为:

线程: thread1 批改共享变量flag为true

并且主线程不会退出，阐明有用户线程在runnable运行中，阐明线程2始终在运行，也阐明线程2获取的变量值先从主内存read到工作内存，而后load给线程2外面工作内存外面变量，而后线程2始终是从本人工作内存获取数据，并且线程2是while的空转，抢占cpu工夫多，所以始终不退出。

2、基于8大原子操作程序数据加载回写流程

8大原子操作是怎么做的？变量是如何读取、如何赋值的？

下面是线程2执行后的后果；所以线程2先读取到flag=false;所以先不会退出。

接着线程1会执行批改flag的操作。将flag批改成true;
第1步：read变量到
第2步: load到工作内存里去；
第3步： use传递给执行引擎做赋值操作。
第4步： 将批改后的值assign到工作内存；这个值会从false变成true;

那么工作内存外面的新值flag=true会立马同步到主内存外面去吗？
更新后的新值不会立马同步到咱们的主内存外面去，他须要期待肯定的机会。机会到了之后会同步到咱们的主内存中去；

同步的时候也须要分为执行两步骤：store和write操作。
然而更新到主内存为true之后，为什么咱们的线程2为什么没有感知到了；起因线程2在while进行循环判断的时候，始终判断的是咱们线程2本人的工作内存外面的值。执行引擎始终判断；判断的值始终是工作内存外面的值。

而后咱们批改代码如下；在while循环判断外面加一个i++的话，那么咱们的线程2能不能及时感知到flag变动的值呢？

因为工作内存中曾经存在这个值的话，就不会从主内存去加载。

咱们批改代码如下：线程3去读取主内存flag的值，因为线程3是从主内存加载的线程1曾经写入的值，此时这个值是flag=true;所以ok。

而后咱们加上一个同步代码快之后的成果呢？

通过下面剖析，咱们的线程2曾经感知到了flag数据的变动。 这是什么起因呢？这里很多人都搞不明确，这里有一个很大的坑：加了同步快之后，咱们的线程2就可能读取到咱们线程1批改的数据，这个是为什么呢？

起因：之前咱们说了，之前没有加同步代码块之前，咱们程序指令始终在循环/或者始终在做i++操作。循环是空的，能够了解为其近似在自旋跑；此时此线程对cpu的应用权限是特地高的；别的线程压根就抢不到cpu的工夫片。咱们加了同步快之后，咱们此时线程会产生阻塞（cpu的应用权限被别的线程抢去了）。产生阻塞之后会产生线程上下文切换。如下：

2、可见性

可见性： 一个线程对某个共享主内存变量进行批改之后，其余与此共享变量相干的线程会立马感知到这个数据的更改。其余线程能够看到某个线程批改后的值。
之前代码咱们发现，咱们两个线程一个线程1批改掉flag的值之后，线程2是load读取不到写的值的，那么为了保障线程将简略标记为变量的可见性。咱们最简略的形式是应用volatile关键字进行批改这个多线程共享的变量。

public class VolatileTest2 {     static volatile boolean  flag = false;     public void refresh(){         this.flag = true;         String threadName = Thread.currentThread().getName();         System.out.println("线程: "+threadName+" 批改共享变量flag为"+flag);     }     public void load(){         String threadName = Thread.currentThread().getName();         while (!flag){         }         System.out.println("线程: "+threadName+" 嗅探到flag状态的扭转"+" flag:"+flag);     }     public static void main(String[] args) {         /**          * 创立两个线程          */         VolatileTest2 obj = new VolatileTest2();         Thread thread1 = new Thread(() -> {             obj.refresh();         }, "thread1");         Thread thread2 = new Thread(() -> {             obj.load();         }, "thread2");         thread2.start();         try {             /**              * 确保咱们线程2先执行              */              Thread.sleep(2000);         }catch (Exception e){             e.printStackTrace();         }         thread1.start();     }}

输入后果如下:

线程: thread1 批改共享变量flag为true线程: thread2 嗅探到flag状态的扭转 flag:true

volatile底层原理
volatile是Java虚拟机提供的轻量级的同步机制
volatile语义有如下两个作用：

  • 可见性：保障被volatile润饰的共享变量对所有线程总是可见的，也就是当一个线程批改了被volatile润饰的共享变量的值，新值总是能够被其余线程立刻得悉。
  • 有序性：禁止指令重排序优化：内存屏障。

volatile缓存可见性实现原理：

  • JMM内存交互层面：volatile润饰的变量的read、load、use操作和assign、store、write必须是间断的，即批改后必须立刻同步到主内存，应用时必须从主内存刷新，由此保障volatile可见性。
  • 底层实现：通过汇编lock前缀指令，他会锁定变量缓存行区域并写会主内存，这个操作成为“缓存锁定”，缓存一致性机制会阻止同时批改两个以上处理器缓存的内存区域数据。一个处理器的缓存回写到内存会导致其余处理器缓存生效。

汇编代码查看：

  • -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp

缓存一致性原理再次分析：
线程1跟线程2都曾经将flag=false的值加载到各自的工作内存，此时flag的状态都是S状态（共享状态），此时线程2将批改flag的值为true时候，其状态变成了M状态，这个时候线程1所在的cpu会嗅探到flag值批改让后将flag对应的缓存行状态设置为I(有效状态)，而后咱们线程1须要应用的时候因为值有效，须要从新加载，此时须要从新加载的话，须要线程2将批改的值增加到主内存，而后线程1才可能加载到正确的值。

Java内存模型内存交互操作：
把一个变量从主内存中复制到工作内存中，就须要按程序地执行read个load操作，如果把变量从工作内存中同步到主内存中，就须要依照程序地执行 store个write操作。然而Java内存模型只要求上述操作必须依照程序执行，而没有保障必须是间断执行的。

以上是程序性而不是连贯的，留神read跟load必须成对呈现；store跟write必须成对呈现。