Java虚拟机规范中定义了Java内存模型（共享内存模型，实现线程与线程之间的通信，其中主内存是逻辑空间），用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果，JMM规范了Java虚拟机与计算机内存是如何协同工作的：规定了一个线程如何和何时可以看到由其他线程修改过后的共享变量的值，以及在必要时如何同步的访问共享变量。

        JMM描述的是一种抽象的概念，一组规则，通过这组规则控制程序中各个变量在共享数据区域和私有数据区域的访问方式，JMM是围绕可见性、有序性、原子性展开的。

        并行：

        指在同一时刻，有多条指令在多个处理器上同时执行，所以无论从微观还是从宏观上来看，二者都是一起执行的

        并发：

        指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

        

        并发和并行的目的都是为了充分利用cpu，不让其闲置，最大化提高cpu使用率，并发本质上是解决多线程之间的同步、互斥、分工问题

并发三大特性：

        可见性：

         当一个线程修改了共享变量的值，其他线程能够看到修改的值。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方法来实现可见性的。

示例：

ublic class VisibilityDemo {
    //线程的共享变量
    private boolean flag=true;
    private int count=0;
    //模拟程序正在执行的方法
    public void load(){
        System.out.println("程序开始加载=====");
        while (flag){
            //TODO 业务逻辑
count++;

        }
        System.out.println("线程："+Thread.currentThread().getName()+"执行完成,跳出循环"+count);
    }
    //修改共享变量
    public void refresh(){
        flag=false;
        System.out.println("线程："+Thread.currentThread().getName()+"对变量flag进行修改,flag:"+flag);
    }
    public static void main(String[] args) throws InterruptedException {
        //创建对象
        VisibilityDemo test = new VisibilityDemo();
        Thread threadA = new Thread(()->test.load(),"threadA");
        threadA.start();
        //main线程休眠一秒 再往下走
        Thread.sleep(1000);
        //B线程对共享变量进行修改 打断A线程的循环
        Thread threadB = new Thread(() -> test.refresh(), "threadB");
        threadB.start();
    }
}

         执行以上代码会一直循环，B线程的修改并不能让A线程感知到,如果用Integer count就会有可见性。

JMM交互模型：

        如果一直从本地内存读，没从主存读到最新的值，就会一直是true。修改后一般不会立刻刷到主存，在B线程没有用这个值，回收之前会刷回去，或者我们对其进行了一些操作，比如用了内存屏障。

        关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、 如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：

lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。

unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用。

load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。

use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。

assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。

store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。

write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

 规则：      

        ① 如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作

        ② 如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。

        ③ Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。不允许read和load、store和write操作之一单独出现。

        ④ 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。

        ⑤ 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。

        ⑥ 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化 （

load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。

        ⑦ 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值 ；如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和 write操作）。

        如何保证可见性 【本质上 jvm层面内存屏障+上下文切换】 

        通过 volatile 关键字修饰保证可见性。此时flag被修改以后，A线程会感知到flag变更为了false,程序跳出循环，如果判断是volatile修饰，会加一个内存屏障(jvm层面的)storeload，底层在汇编层面会加lock前缀指令，具有类似内存屏障的功能，会使缓存失效，所以就会去加载主存的内容，实现了可见性

//线程的共享变量
private volatile boolean flag=true;
private int count=0;

volatile的特性 ：

        可见性：对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。  

        有序性：对volatile修饰的变量的读写操作前后加上各种特定的内存屏障来禁止指令重排序来保障有序性。

        原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++ 这种复合操作不具有原子性（基于这点，通常认为volatile不具备原子性），volatile仅仅保证对单个volatile变量的读/写具有原子性，而锁的互斥执行的特性可以确保对整个临界区代码的执行具有原子性。64位的long型和double型变量，只要它是volatile变量，对该变量的读/写就具有原子性。        

volatile读-写的内存语义 ：

        当读一个volatile变量时，JMM会把该线程对应的本地内存（共享变量的副本）置为无效，线程接下来将会从主内存中读取共享变量。        

        当写一个volatile变量时，JMM会把该线程对应的本地内存（共享变量的副本）中的共享变量值刷新到主内存。

volatile可见性实现原理

JMM内存交互层面实现为：volatile修饰的变量的read、load、use操作和assign、store、write必须是连续的，即修 改后必须立即同步回主内存，使用时必须从主内存刷新，由此保证volatile变量操作对多线程的可见性。

硬件层面实现：通过lock前缀指令，会锁定变量缓存行区域并写回主内存，这个操作称为“缓存锁定”， 缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据。一个处理器的缓存回写到内存会导致其他处理器的缓存无效。

---------------------------------------------

内存屏障保证可见性，可显示的调用内存屏障

 释放时间片也可以实现可见性，释放时间片，此时自己的缓存会失效，上下文切换，加载上下文，重新去主内存中去加载最新的值

 

 通过 synchronized 关键字保证可见性。

代码里有System.out.println（）也可以实现可见性，跳出循环

   println用了synchronized, 底层还是调用的内存屏障实现，如果调用了 业务逻辑中如果有Thread.sleep(1)，也是一样的原理会调用内存屏障

通过 final 关键字保证可见性。

比如用Integer count;修饰，底层是用了final修饰，

public Integer(int value) {
    this.value = value;
}

 拆包的时候用的这个方法来获取Integer的值

 本地内存也会存在过期的问题

/模拟执行时长
public static void shortWait(long interval){
    //获取纳秒
    long start =System.nanoTime();
    long end;
    do{
        end=System.nanoTime();
    }while (start+interval>=end);
}

结果会跳出循环