我们今天要特别重点讲的，也就是我们本文的目的来理解 J V M 与我们的内存两者之间是如何协调工作的，它的名字就是Java内存模型(JMM)。

一 打牢基础

原子性是一种按原子方式的操作，那你有可能问了“原子方式”是啥？就是不可中断的意思。你也可以理解不能再分。要么不执行，要么用原子的方式来执行，在这个过程中是不会被其他线程中断。

有什么栗子吗？

眼界为实

 ​
 class Data{
     AtomicInteger atomicInteger = new AtomicInteger();
     volatile int number=0;
     public void numberIncrement(){
         this.number++;
     }
     
     public void atomicIntegerIncrement(){
         this.atomicInteger.incrementAndGet();
     }
 }
 ​
 public class Main {
 ​
     public static void main(String[] args) {
         Data data = new Data();
         for (int i = 0; i < 10; i++) {
             new Thread(()->{
                 for (int j = 0; j < 1000; j++) {
                     data.numberIncrement();
                     data.atomicIntegerIncrement();
                 }
             },"t"+i).start();
         }
 ​
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        
         System.out.println("volatile修饰的int type:"+data.number);
         System.out.println("原子类:"+data.atomicInteger);
     }
 }
 ​

再看下不是原子性的案例

 ​
 class Data{
     volatile int number=0;
     public void numberIncrement(){
         this.number++;
     }
 }
 public class Main {
 ​
     public static void main(String[] args) {
         Data data = new Data();
         for (int i = 0; i < 10; i++) {
             new Thread(()->{
                 for (int j = 0; j < 1000; j++) {
                     data.numberIncrement();
                 }
             },"t"+i).start();
         }
 ​
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
         System.out.println(data.number);
     }
 }
 ​

这个程序目的是 10 个线程把 number 变为 10000,因为 volatile 不保证原子性,所以是达不到效果的.输出结果如下：

这两操作是原子性的，也就是顺序执行且不能被打断的，要么都执行成功，要么都失败

可见性是线程对共享变量修改的可见状态。假如一个线程修改了一个共享变量的值，其他线程立马知道共享变量改了。比较好的例子就是 volatile 变量了。这里叙述下大致的原理：

首先你的 volatile 变量对所有的线程都是可见的，指的是你执行完 assign 之后立即就会把共享变量复制到主内存上去；在其他任意一个线程读取主内存对象时候，读取都是存到自己的线程私有内存里面，它是都会刷新主内存。这仅仅是针对同一个线程，在主内存上是表现数据一致性的。但是那如果是其他线程的私有内存它们一起来存取到各其他线程的私有内存，那你私有内存和你的主内存的数据那可就不一定相同啊。这就是 volatile 它是不能保证啥？不能保证线程安全的。

怎么样让它线程安全呢？

• 第一个条件：运算结果并不依赖变量的当前值，或者你能保证只有一个线程修改变量的值，就是上面我说的第一种情况。

• 第二个条件：变量不需要和其它的状态变量共同参与不变约束。

最后一个有序性意思说如果在本线程内观察，所有的操作都是有序的，说明线程间的操作具有有序性。那肯定有无序的，我们可以用java为我们提供好的 volatile 和 synchronized 两个关键字来保证线程之间操作有序就完成。

先来回顾下指令重排序

因为在JVM内部，我们为了提高性能，编译器和处理器会对指令做重排序，但是JMM确保在不同的编译器和不同的处理器平台之上，通过插入特定类型的 Memory Barrier,

有序性是指：按照代码的既定顺序执行。

说的通俗一点，就是代码会按照指定的顺序执行，例如，按照程序编写的顺序执行，先执行第一行代码，再执行第二行代码，然后是第三行代码，以此类推。如下图所示。

指令重排序 编译器或者解释器为了优化程序的执行性能，有时会改变程序的执行顺序。但是，编译器或者解释器对程序的执行顺序进行修改，可能会导致意想不到的问题！

在单线程下，指令重排序可以保证最终执行的结果与程序顺序执行的结果一致，但是在多线程下就会存在问题。

如果发生了指令重排序，则程序可能先执行第一行代码，再执行第三行代码，然后执行第二行代码，如下所示。

数据依赖性

如果两个操作访问同一个变量，且这两个操作中有一个为写操作，

好了我们要先整明白它有啥用？

它规定了一个线程如何并且能够及时看到其他线程修改过后的变量的值，及如何到内存去同步咱们的共享变量。

happens-before先行发生原则

它用于描述两个操作在内存中的可见性，这样可以判断数据是否存在竞争，线程是否安全的主要根据。

 ​
 int a = 10;
 b = b + 1;
 ​

CPU有时候会为了计算单元的利用率将其进行指令重排，如果b = b + a 就不会进行指令重排，因为b的结果依赖于 a 的值。

JVM对内存模型的实现

在JVM内部，内存模型大致分为两大块：线程栈区和堆。如图： JVM中运行的每个线程都有自己的线程栈，线程栈包含了当前线程执行的方法调用相关信息，我们也可以叫它调用栈。

从上图得出，线程A和线程B之间如果要通信的话，必须要经历下面2个步骤：

首先，线程A里面已更新的共享变量刷新到主内存里面去。 然后，线程B到主内存去读取线程A之前已更新过的共享变量。

画图说明这两个步骤： 本地内存A和B有主内存中共享变量x的副本。假设初始时，这三个内存中的x值都为0。线程A在执行时，把更新后的x值（我们先假设值为1)临时存放在自己的本地内存A中。假如它们两个需要通信了，线程A首先把自己本地内存的x值变成了1。随后，线程B到主内存中读取线程A更新后的x值，此时线程B的本地内存的x值也变成了1。

它是咋来的呢？

JVM规范由它来定义这玩意，你想吗，内存模型，内存模型，就是告诉你在JVM中你的内存是如何分布的。根据它特有的结构，就它的结构自然而然的表示出来它的功能。它的结构，我们先瞄一眼

看到上面图没有，小伙伴们先回忆概念：

Heap

优点：运行时数据区，动态分配内存大小，有 gc; 缺点：因为要在运行时动态分配内存，所以它的存取速度比栈要慢一些，对象是放在堆上，静态类型和那个类的定义也是一起存储在堆上的。

stack

优点：存取速度比 Heap 快，但是肯定比寄存器要慢一丢丢。 缺点：由于是JVM提前划分好的，那它的数据大小和生命周期那就是确定的了，说明缺乏灵活性，你想你下有哪些用到的类型它的大小是固定的呢！莫错，基本数据类型，那就多得很。（譬如char, boolean, double, int等，提示一下对象句柄也属于基本类型变量的哦）。

当一个线程去访问一个对象时， 可以去访问对象的成员变量， 如果有两个线程访问对象的成员变量，则每个线程都有对象的成员变量的私有拷贝。

读完你也许一脸懵逼，这是啥？

正如上面讲到的，Java内存模型和硬件内存结构并不一致。硬件内存里面没有区分堆和栈，

关于我

这里是小希，一个热爱技术的Java程序猿，公众号「码工是小希」里将会定期分享数据结构，计算机网络，Java，分布式，数据库等精品原创文章，

非常感谢各位小哥哥小姐姐们能看到这里，原创不易，文章有帮助可以关注，点个赞，分享与评论，都是支持（莫要白嫖）！

坚持就会很酷

下期见