当前位置：首页 > news >正文

多线程篇-3--java内存模型（主内存，共享内存，三大特性，指定重排）

news 来源：原创 2025/5/14 5:42:38

Java内存模型

Java Memory Model，简称JMM，本身是一种抽象的概念，实际上并不存在，它描述的是一组规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

（1）、到底规范了什么？

1、定义程序中各种变量的访问规则。
2、把变量值存储到内存的底层细节。
3、从内存中取出变量值的底层细节。

（2）、标准流程

1、所有变量存储在主内存（即：所有变量都在堆内存开辟）
2、主内存是虚拟机内存的一部分（即：jvm的内存分为堆内存，栈内存等）
3、每条线程有自己的工作内存（即：每个线程需要开辟属于自己的独立空间）
4、线程的工作内存保存变量的主内存副本（即：每个线程需要哪些变量，会先从主内存加载到自己的独立空间中）
5、线程对变量的操作必须在工作内存中进行（即：每个线程只能在自己的独立空间中工作，彼此是隔离的）
6、不同线程之间无法直接访问对方工作内存中的变量（即：每个线程之间是相互隔离的，不能看到对方的空间）
7、线程间变量值的传递均需要通过主内存来完成（即：线程之间想要通信，必须先将自己的副本写回到主内存中，其他线程在从主内存中读取到其他线程写的数据）

理解：
由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存空间（通常也称为栈内存空间），工作内存是每个线程的私有数据区域。而Java内存模型中规定所有变量都存储在主内存，主内存是共享区域，所有线程都可以访问。但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写会主内存，不能直接在主内存中操作变量。各个线程中的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成。
（实际创建创建线程开辟的空间是栈内存空间，栈内存中保存的是变量的引用（=前半的定义），真正变量数据（=右边new的对象）还是在堆内存中，不过副本引用都是在堆内存新开辟出来的，所以彼此之间还是隔离的。）

其简要访问过程图例：
在这里插入图片描述

（3）、主内存和工作内存

1、主内存（共享内存）

主内存（共享内存）是所有线程共享的内存区域，主要存储实例的数据（即：new出来的对象）。如：每个对象的实例变量、数组元素和静态变量等都存储在主内存中。
在Java中，对象和变量都存储在堆内存中，而每个线程有自己的栈内存来保存方法调用和局部变量的信息。当多个线程需要操作同一个对象或变量时，这些对象或变量就成为了共享数据，存在于共享内存中。共享内存使得线程间通信成为可能，但也带来了并发控制的问题，比如竞态条件（race condition）。

主要包含区域：
1、Java堆中对象实例数据部分（堆内存）
2、对应于物理硬件的内存（物理内存）

2、工作内存

工作内存是指每个线程独有的内存空间，存储了该线程使用的变量的副本。线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，不能直接操作主内存中的变量。（即使是volatile修饰的变量，也会在工作内存中创建变量副本，在从主内存中读取数据到副本中。在运算操作时，也都是先从主内存加载到工作内存副本中，再从副本中取出做运算）。

主要包含区域：
1、Java栈中的部分区域（栈内存）
2、优先存储于寄存器和高速缓存

（4）、内存模型的三大特性

1、原子性

（1）、概念
原子性是指一个操作或多个操作要么全部执行并且执行过程中不会被任何因素打断，要么完全不执行。
在多线程环境中，如果某个操作不是原子的，那么在执行过程中可能会被其他线程中断，导致中间状态被其他线程看到，从而引发各种并发问题，如竞态条件（race condition）、数据不一致等。

（2）、常用保证原子性的方法
synchronized，原子类（AtomicInteger等），Lock等。

（3）、代码示例

import java.util.concurrent.atomic.AtomicInteger;public class AtomicCounter {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet();   // 原子操作}public int getCount() {return count.get();}
}

2、可见性

（1）、概念
可见性是指当一个线程修改了共享内存中的某个变量的值，其他线程能够立即看到这个变量的新值。

在Java中，默认情况下，线程工作内存中保存了主内存中变量的副本。如果一个线程修改了一个变量的值，这个新值会首先保存到该线程的工作内存中，而不是立即写回主内存。因此，其他线程可能仍然看到的是这个变量的旧值，这就产生了可见性问题。

（2）、常用保证可见性的方法
1、volatile关键字
当一个变量被声明为volatile类型时，它会强制每次读取该变量时都会从主内存中读取最新的值，而不是使用线程缓存中的值；同时，每次写入该变量时也会立即将新的值写回到主内存中。这确保了所有线程都能看到最新的值。

2、synchronized关键字
通过使用synchronized关键字定义同步代码块或方法，可以确保同一时刻只有一个线程能够执行这段代码，从而避免了数据的不一致性问题。当一个线程退出同步代码块时，它对变量所做的任何更改都将被写回主内存，这样下一个进入同步代码块的线程看到的数据都是最新的值。

3、final关键字
对于被声明为final的字段，在构造函数中初始化后，其值就不能再改变。这意味着一旦对象构造完成，所有线程都可以安全地访问这些final字段，而无需额外的同步措施。

4、原子类
Java提供了诸如AtomicInteger等原子类，它们提供了原子操作的方法，可以在多线程环境中保证操作的原子性和可见性。

（3）、代码示例

public class VolatileVisibility {private volatile boolean flag = false;public void writer() {flag = true; // 修改flag，被volatile修饰，会立即写会主内存中}public void reader() {if (flag) {   // 读取flag，会从主内存加载值// 执行某些操作}}
}

在这个例子中，flag被声明为volatile，确保了writer方法中对flag的修改对reader方法是可见的。

3、有序性

（1）、概念
有序性是指程序的执行顺序按照代码的先后顺序执行。

在多线程环境中，编译器和处理器为了优化性能，可能会对指令进行重排序，但这不应该影响程序的最终结果。
有序性确保了程序的执行顺序符合开发者的预期，避免了因指令重排序导致的并发问题。

（2）、常用保证有序性的方法
1、volatile关键字
volatile变量的读写操作会产生内存屏障（Memory Barrier），确保在读取或写入volatile变量之前/之后的指令不会被重排序。

public class VolatileOrdering {private volatile boolean flag = false;private int data = 0;public void writer() {data = 42; // 写入dataflag = true; // 设置flag为true，内存屏障会保证data=42一行，一定会在之前执行}public void reader() {if (flag) { // 检查flagint localData = data; // 读取data// 使用localData}}
}

2、synchronized`关键字
通过锁的获取和释放操作，确保了指令的有序性。

3、java.util.concurrent.locks.Lock接口
同样通过锁的获取和释放操作，确保了指令的有序性。

（3）、有序性总结

如果在本线程内观察，所有的操作都是有序的；（单线程运行结果）
如果在一个线程中观察另一个线程，所有的操作都是无序的。（多线程运行结果，可能会不安全）
理解：
前半句是指“线程内似表现为串行的语义”（Within-Thread As-If-Serial Semantics），
在同一个线程内部，程序员看到的操作（例如读写变量）是按照代码中定义的顺序进行的。这意味着对于单个线程而言，它自己的所有操作看起来都是遵循程序中指定的顺序执行的。这是因为在单个线程中，CPU指令通常会按照源代码中编写的顺序来执行。
但是需要注意的是，这并不意味着底层硬件或编译器不会对指令进行重排序优化。实际上，为了提高性能，编译器和处理器可能会对指令进行重排序，只要这些改变不会影响到该线程内部的逻辑正确性。然而，从程序员的角度来看，这些操作仍然保持了“顺序一致性”，即它们表现得就像按照原始顺序执行一样。

后半句是指“指令重排序”现象和“工作内存与主内存同步延迟”现象。
在多线程环境中，每个线程都有自己的工作缓存，用来存储数据副本。当一个线程更新某个数据时，这个更新并不会立即反映到其他线程的工作缓存中，除非使用了合适的同步手段来确保内存可见性。因此，从一个线程的角度看另一个线程的操作，如果没有正确的同步，就可能出现操作看似“无序”的现象。

（5）、内存间的交互

1、lock（锁定）
作用于主内存的变量，把一个变量标识为一条线程独占的状态。（即：添加了指定线程的标记，只有这个线程可以用，其他线程就不能访问了）
2、unlock（解锁）
作用于主内存的变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。（即：清除了标记，恢复了自由，谁在访问都可以）
3、read（读取）
作用于主内存的变量，把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。（即：去读主内存数据过程）
4、load（载入）
作用于工作内存的变量，把read操作从主内存中得到的变量值放入工作内存的变量副本中。（即：将读取主内存数据写入工作内存的过程）
5、use（使用）
作用于工作内存的变量，把工作内存中的一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作。（即：线程使用自己的变量副本）
6、assign（赋值）
作用于工作内存的变量，把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。（即：线程修改自己的变量副本的值）
7、store（存储）
作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write操作使用。（即：读取工作内存的副本值）
8、write（写入）
作用于主内存的变量，把store操作从工作内存中得到的变量值放入主内存的变量中。（即：将工作内存的副本值写入到主内存变量中）

（6）、指令重排

1、为什么要重排
计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排序。

2、有哪几种重排
（1）、编译器优化重排
编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
（2）、指令级的并行重排
现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
（3）、内存系统的重排
由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。
在这里插入图片描述
注意：
单线程环境里面确保最终执行结果和代码顺序的结果一致。
处理器在进行重排序时，必须要考虑指令之间的数据依赖性。
多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

3、重排代码示例

public class VolatileResort {static int num = 0;static boolean flag = false;public static void init() {num= 1;flag = true;}public static void add() {if (flag) {num = num + 5;System.out.println("num:" + num);}}public static void main(String[] args) {init();new Thread(() -> {add();},"子线程").start();}
}

如上代码，理论上排序应该是固定的，但是由于添加了if判断，因为存在多线程的缘故，看谁先抢到CPU资源，对这段代码的影响就是会造成add方法和init方法的先后执行顺序不确定，进而导致输出的结果不一致。

4、volatile怎么实现禁止指令重排？

原理：在volatile生成的指令序列前后插入内存屏障（Memory Barries）来禁止处理器重排序。内存屏障在之后会详细说明。

学海无涯苦作舟！！！