JMM 定义

内存模型定义了共享内存系统中多线程程序读写操作行为的规范，来屏蔽各种硬件和操作系统的内存访问差异，来实现 Java 程序在各个平台下都能达到一致的内存访问效果。

Java 内存模型的主要目标是定义程序中各个变量的访问规则，也就是在虚拟机中将变量存储到内存以及从内存中取出变量（这里的变量，指的是共享变量，也就是实例对象、静态字段、数组对象等存储在堆内存中的变量。而对于局部变量这类的，属于线程私有，不会被共享）这类的底层细节。

通过这些规则来规范对内存的读写操作，从而保证指令执行的正确性。它与处理器有关、与缓存有关、与并发有关、与编译器也有关。他解决了 CPU多级缓存、处理器优化、指令重排等导致的内存访问问题，保证了并发场景下的可见性、原子性和有序性。

内存模型解决并发问题主要采用两种方式：限制处理器优化和使用内存屏障

Java 内存模型定义了线程和内存的交互方式，在 JMM 抽象模型中，分为主内存、工作内存。主内存是所有线程共享的，工作内存是每个线程独有的。线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，不能直接读写主内存中的变量。并且不同的线程之间无法访问对方工作内存中的变量，线程间的变量值的传递都需要通过主内存来完成，他们三者的交互关系如下，定义了8种原子操作。

image.png

Java 内存模型的抽象结构如下。

image.png

JMM 如何解决可见性、原子性、有序性的问题

Java 中已经提供了一系列处理并发编程的关键字，比如 volatile、synchronized、final 这些就是 Java 内存模型封装了底层的实现后提供给开发人员使用的关键字。

所以 Java 内存模型除了定义了一套规范，还提供了一系列并发编程的关键字。

volatile、synchronized、final 这些关键字分别可以解决哪些线程的安全性问题呢？

  • volatile 可以解决可见性、有序性的问题
  • synchronized 可以解决可见性、原子性、有序性的问题（synchronized 是全能型关键字）
  • final 可以解决可见性问题

下面我们通过使用 volatile 和 synchronized 关键字来解决可见性、原子性、有序性的问题，对比线程的安全性问题

可见性

  1. public class VisibleDemo {
  3.     private volatile static boolean stop = false;
  5.     public static void main(String[] args) {
  6.         Thread thread = new Thread(new Runner());
  7.         thread.start();
  8.         try {
  9.             TimeUnit.SECONDS.sleep(1);
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.         stop = true;
  14.     }
  16.     private static class Runner implements Runnable {
  18.         private int i;
  20.         @Override
  21.         public void run() {
  22.             while (!stop) {
  23.                 i++;
  24.             }
  25.             System.out.println(i);
  26.         }
  27.     }
  28. }

通过在类属性 stop 上增加 volatile 关键字，解决了可见性问题。在 main 方法中把 stop 属性改为 true，子线程终止了执行。

原子性

  1. public class AtomicDemo {
  3.     private static int count;
  5.     public static void main(String[] args) {
  6.         for (int i = 0; i < 1000; i++) {
  7.             new Thread(new Runner()).start();
  8.         }
  9.         try {
  10.             Thread.sleep(4000);
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  14.         System.out.println("运行结果：" + count);
  15.     }
  17.     private static class Runner implements Runnable {
  19.         @Override
  20.         public void run() {
  21.             synchronized (AtomicDemo.class) {
  22.                 try {
  23.                     Thread.sleep(1);
  24.                 } catch (InterruptedException e) {
  25.                     e.printStackTrace();
  26.                 }
  27.                 count++;
  28.             }
  29.         }
  30.     }
  31. }

通过在 run 方法中增加 synchronized 同步块，解决了 count++ 的原子性问题，count 最终的运行结果是1000。

作者：殷建卫 链接：https://www.yuque.com/yinjianwei/vyrvkf/hi3xiq 来源：殷建卫 - 架构笔记 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。