JMM内存模型-CFANZ编程社区

计算机的组成

冯·诺依曼结构计算机

冯·诺依曼

美籍匈牙利科学家冯·诺依曼最先提出程序存储的思想，并成功将其运用在计算机的设计之中，根据这一原理制造的计算机被称为冯·诺依曼结构计算机。

冯.诺依曼计算机模型

先从内存中取出第一条指令，通过控制器的译码，按指令的要求，从存储器中取出数据进行指定的运算和逻辑操作等加工，然后再按地址把结果送到内存中去。接下来，再取出第二条指令，在控制器的指挥下完成规定操作。
按程序编排的顺序，一步一步地取出指令，自动地完成指令规定的操作是计算机最基本的工作模型这一概念就是冯·诺依曼提出的。

冯·诺依曼又被称为 “现代计算机之父”。

计算机的五大组成部分

控制器: 计算机的控制系统, 功能是对程序规定的控制信息进行解释，根据其要求进行控制，调度程序、数据、地址，协调计算机各部分工作及内存与外设的访问。
运算器: 计算机的运算系统, 逻辑运算（判断事物的对与错）数学运算（1 + 1）控制器 + 运算器 = 中央处理器（CPU）
存储器: 内存, 基于电工作的, 优点: 读取速度快, 缺点: 断电数据丢失, 外存, 优点: 可以永久存储数据, 缺点: 读取速度慢。
输入设备: 键盘、鼠标、麦克风、摄像头、触摸屏等。
输出设备: 显示器, 打印机, 扫描仪。

JMM内存模型_并发编程

操作系统

操作系统也是应用程序。
是针对计算机硬件，将操作硬件中的复杂，难懂的接口封装起来。
暴露给用户简单快捷的操作接口。
帮助用户管理、协调、操作、调度计算机的各个硬件。

CPU 的内部结构

JMM内存模型_并发编程_02

控制单元(CU): 用于执行计算机指令或者 Client Unit 监控系统的监控客户端单元。组成，指令寄存器IR，根据用户预先编好的程序，依次从存储器中取出各条指令，放在指令寄存器IR中，指令译码器ID，通过指令译码（分析）确定应该进行什么操作，操作控制器OC，然后通过操作控制器OC，按确定的时序，向相应的部件发出微操作控制信号。
运算单元: 可以执行算术运算和逻辑运算, 运算器接受控制单元的命令而进行动作。
数据单元: 是 CPU 中暂时存放数据的地方, CPU 访问寄存器所用的时间要比访问内存的时间短, 采用寄存器，可以减少 CPU 访问内存的次数，从而提高了 CPU 的工作速度, 组成, Cache 缓存, CPU 缓存: 位于 CPU 与内存之间的临时存储器，它的容量比内存小但交换速度快。寄存器组, 寄存器组是 CPU 中暂时存放数据的地方，里面保存着那些等待处理的数据。
程序计数器(PC): 程序计数器是用于存放下一条指令所在单元的地址的地方。
内存管理单元(MMU): MMU 位于处理器内核和连接高速缓存以及物理存储器的总线之间。当处理器内核取指令或者存取数据的时候，都会提供一个有效地址(effective address)或者称为逻辑地址、虚拟地址。用于完成虚拟内存和物理内存的映射。

CPU 与内存交互

JMM内存模型_并发编程_03

组成结构图

JMM内存模型_并发编程_04

JVM 内存模型

内存模型图

JMM内存模型_并发编程_05

内存模型

程序计数器(线程私有): 是当前线程锁执行字节码的行号治时期，每条线程都有一个独立的程序计数器，这类内存也称为 “线程私有” 的内存。正在执行 Java 方法的话，计数器记录的是虚拟机字节码指令的地址(当前指令的地址)如果是 Native 方法，则为空。
Java 虚拟机栈(线程私有): 每个方法在执行的时候也会创建一个栈帧，存储了局部变量，操作数，动态链接，方法返回地址。每个方法从调用到执行完毕，对应一个栈帧在虚拟机栈中的入栈和出栈。通常所说的栈，一般是指在虚拟机栈中的局部变量部分。局部变量所需内存在编译期间完成分配
本地方法栈(线程私有): 和虚拟机栈类似，主要为虚拟机使用到的 Native 方法服务。
Java 堆(线程共享): 被所有线程共享的一块内存区域，在虚拟机启动的时候创建，用于存放对象实例。
方法区(线程共享): 被所有方法线程共享的一块内存区域。用于存储已经被虚拟机加载的类信息，常量，静态变量等。这个区域的内存回收目标主要针对常量池的回收和堆类型的卸载。

JMM 与 JVM

JMM 与 JVM 内存区域的划分是不同的概念层次。
JMM 描述的是一组规则。
通过这组规则控制程序中各个变量在共享数据区域和私有数据区域的访问方式。

Java 内存模型 JMM

JMM 是什么

JMM(Java Memory Model) 简称 JMM 定义了 Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式, 制定的一种规范。

通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

为什么要有 JMM

因为在不同的硬件生产商和不同的操作系统下，内存的访问逻辑有一定的差异，结果就是当你的代码在某个系统环境下运行良好，并且线程安全，但是换了个系统就出现各种问题。Java 内存模型，就是为了屏蔽系统和硬件的差异，让一套代码在不同平台下能到达相同的访问结果。JMM 从 Java 5 开始的 JSR-133 发布后，已经成熟和完善起来。

模型图

JMM内存模型_并发编程_06

主要划分

主内存

在 JMM 中主内存属于共享数据区域，对应着 JVM 中堆和方法区。
Java 内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问。
主内存对应的是 Java 堆中的对象实例部分。
所有线程创建的对象都存放在主内存中。
从更底层的来说，主内存对应的是硬件的物理内存。
由于是共享数据区域，多条线程对同一个变量进行访问可能会发生线程安全问题。

工作内存

工作内存数据，线程私有数据区域，对应 JVM 中包括程序计数器、虚拟机栈, 以及本地方法栈。
工作内存对应的是栈中的部分区域。
从更底层的来说, 工作内存对应的是寄存器和高速缓存。
私有信息，基本数据类型，直接分配到工作内存，引用的地址存放在工作内存, 引用的对象存放在堆中。

工作方式

线程修改私有数据, 直接在自己的工作空间当中修改。如果修改的是共享数据, 把数据复制到工作空间当中, 在工作空间中修改, 修改完成后，刷新到主内存当中去。

为什么要这样设计

JVM 在设计的时候考虑到，如果 JAVA 线程每次读取和写入变量都直接操作主内存，对性能影响大。
所以每条线程拥有各自的工作内存，工作内存中的变量是主内存中的一份拷贝。
线程对变量的读取和写入，直接在工作内存中操作，而不能直接去操作主内存中的变量。
但是这样就会出现一个问题，当一个线程修改了自己工作内存中变量，对其他线程是不可见的，会导致线程不安全的问题。
JMM 制定了一套标准来保证开发者在编写多线程程序的时候，能够控制什么时候内存会被同步给其他线程。

JMM 数据原子操作

JMM内存模型_并发编程_07

lock-锁定：把主内存当中的一个变量标记为一条线程独占状态。
unlock-解锁：把一个处于锁定状态的变量解锁，解锁后后的变量才可以被其他线程锁定占用。
read-读取：把一个变量值从主内存读取到线程的工作内存当中。
load-载入：它把 read 操作从主内存中得到的变量值放入工作内存的变量副本中。
use-使用：把工作内存中的一个变量值传递给执行引擎使用。
assign-赋值：把一个从执行引擎接收到的值赋给工作内存的变量。
store-存储：把工作内存中的一个变量的值传送到主内存中。
write-写入：把 store 操作从工作内存中的一个变量的值传送到主内存的变量中。

注意事项

不允许一个线程把一个未修改过的变量写入到主内存当中。
变量初始化只允许在主内存当中进行, 不能直接在工作内容当中初始化变量。
如果一个变量被锁定, 别的线程不能再去对它进行锁定，直到它进行解锁之后才能够进行锁定，执行多少次加锁就要对他进行多少次解锁。
没有被执行所操作，就不能对它进行解锁操作。
对一个变量进行解锁操作，就必须把它刷新到主内存当中之后才能够进行解锁。

CPU 缓存策略

缓存概述

CPU 为了提升执行效率，减少 CPU 与内存的交互(交互影响 CPU 效率)一般在 CPU 上集成了多级缓存架构。

CPU 缓存策略图

JMM内存模型_java_08

CPU 读取数据时, 会先从自己的寄存器当中读取. 如果没有再从 Cache 当中读取数据. 如果 Cache 当中也没有，再从内存当中获取，然后再依次缓存。

多核 CPU 结构图

JMM内存模型_java_09

三级缓存

L1 Cache

分为数据缓存和指令缓存，逻辑核独占。
CPU 所有操作的数据全部在寄存器当中完成。
寄存器比 L1(L1 Cache)要快。
离 CPU 内核最近。
内核独享。
L1 一种存指令，一种存数据。

L2 Cache

内核独享。

L3 Cache

所有内核共享。

缓存读取时间

Registers: <1ns
L1 cache: 约1ns
L2 cache: 约3ns
L3 cache: 约15ns
主内存: 约80ns

缓存行 Cache Line 概念

缓存是有最小的存储区块缓存行 Cache Line 组成。
计算机当中为了让效率更高, 在读取数据时, 是一块一块进行读取的。
cache Line 能够读取的大小是 64 个字节。

JMM内存模型_缓存_10

程序的局部性原理

问题

构建数组

JMM内存模型_缓存_11

创建一个大的二维数组

/**
 * @author BNTang
 **/
public class DemoTest {
    private static long[][] arrays;

    public static void main(String[] args) {
        // array[1024 * 1024][6] 空间大小的数组
        arrays = new long[1024 * 1024][];

        for (int i = 0; i < 1024 * 1024; i++) {
            arrays[i] = new long[6];

            for (int j = 0; j < 6; j++) {
                arrays[i][j] = 1L;
            }
        }
    }
}

两种方式将所有的元素进行求和

/**
 * @author BNTang
 **/
public class DemoTest {
    private static long[][] arrays;

    public static void main(String[] args) {
        // array[1024 * 1024][6] 空间大小的数组
        arrays = new long[1024 * 1024][];

        for (int i = 0; i < 1024 * 1024; i++) {
            arrays[i] = new long[6];

            for (int j = 0; j < 6; j++) {
                arrays[i][j] = 1L;
            }
        }

        // 对所有元素遍历,进行求和
        long sum = 0L;
        // 记录起始赶时间
        long start = System.currentTimeMillis();
        // 对所有的元素进行求和
        for (int i = 0; i < 1024 * 1024; i++) {
            for (int j = 0; j < 6; j++) {
                sum += arrays[i][j];
            }
        }
        System.out.println("time: " + (System.currentTimeMillis() - start));
        System.out.println("res: " + sum);
    }
}

/**
 * @author BNTang
 **/
public class DemoTest {
    private static long[][] arrays;

    public static void main(String[] args) {
        // array[1024 * 1024][6] 空间大小的数组
        arrays = new long[1024 * 1024][];

        for (int i = 0; i < 1024 * 1024; i++) {
            arrays[i] = new long[6];

            for (int j = 0; j < 6; j++) {
                arrays[i][j] = 1L;
            }
        }

        long sum = 0L;
        long start = System.currentTimeMillis();
        for (int j = 0; j < 6; j++) {
            for (int i = 0; i < 1024 * 1024; i++) {
                sum += arrays[i][j];
            }
        }
        System.out.println("time: " + (System.currentTimeMillis() - start));
        System.out.println("res: " + sum);
    }
}