用实例带你深入理解 Java 内存模型

2022 年 2 月 24 日
本文字数：2882 字
阅读完需：约 9 分钟

本文分享自华为云社区《一文带你图解Java内存模型》，作者：龙哥手记。

我们今天要特别重点讲的，也就是我们本文的目的来理解 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 等，提示一下对象句柄也属于基本类型变量的哦）。