JMM(Java内存模型)讲解_请详细解释一下 java 内存模型(jmm)的核心概念,以及它在并发编程中的作用。-优快云博客

本文链接：https://blog.youkuaiyun.com/zwz1342/article/details/145722974

JMM（Java Memory Model，Java内存模型）是Java并发编程中的一个非常重要的概念，它帮助我们理解Java程序在多线程环境下内存操作的行为。别担心，我会用简单易懂的方式来讲解，让你轻松掌握它的核心内容。

1. 什么是JMM？

定义

JMM是Java内存模型的简称，它定义了Java程序中内存操作的规则和规范。简单来说，JMM规定了Java程序中的变量存储在内存中的方式，以及线程如何读取和写入这些变量。

为什么需要JMM？

在多线程环境中，多个线程可能会同时访问和修改共享变量。如果没有一个统一的规范，就可能出现各种问题，比如数据不一致、线程安全问题等。JMM就是为了解决这些问题而设计的。

理解JMM的基本概念

JMM定义了Java程序中多线程如何与内存交互，确保线程之间的可见性、有序性和原子性。

可见性：一个线程对共享变量的修改，其他线程能否立即看到。
有序性：代码的执行顺序是否与编写的顺序一致。
原子性：操作是否不可分割，不会被其他线程干扰。

2. JMM的核心概念

2.1 主内存与线程私有内存

在JMM中，内存被分为主内存和线程私有内存：

主内存：所有线程共享的内存区域，存储了程序中的实例变量、静态变量等。
线程私有内存：每个线程独有的内存区域，包括寄存器、栈内存等。线程私有内存中的变量对其他线程不可见。

2.2 变量的存储位置

堆内存：存储对象实例和数组，这些变量是所有线程共享的。
栈内存：每个线程有自己的栈内存，存储局部变量、方法调用等信息。栈内存中的变量是线程私有的。

举个例子

假设我们有一个变量int x = 10，它被存储在主内存中。当线程A需要使用这个变量时，它会将x的值从主内存复制到自己的线程私有内存中。线程A对x的修改只会反映在自己的私有内存中，不会立即影响其他线程。

3. 内存操作的规则

3.1 读写操作

读操作：线程从主内存读取变量的值到自己的私有内存。
写操作：线程将自己的私有内存中的变量值写回到主内存。

3.2 可见性问题

由于线程有自己的私有内存，一个线程对变量的修改可能不会立即反映到主内存中，这就导致了可见性问题。也就是说，一个线程修改了变量，其他线程可能看不到这个修改。

解决方法

JMM通过内存屏障和volatile关键字来解决可见性问题。使用volatile修饰的变量，线程每次读取时都会直接从主内存读取，写入时也会直接写入主内存，从而保证了变量的可见性。

4. 内存屏障

定义

内存屏障（Memory Barrier）是一种特殊的指令，用于控制内存操作的顺序。它确保在屏障之前的内存操作不会被屏障之后的操作重排序。

作用

防止指令重排序：确保线程对变量的读写操作按照预期的顺序执行。
保证可见性：确保线程对变量的修改能够及时反映到主内存中。

举个例子

int a = 1;
int b = 2;

在没有内存屏障的情况下，JVM可能会将这两条指令重排序为b = 2; a = 1;。但如果我们在a = 1;之后插入一个内存屏障，就可以防止这种重排序。

5. happens-before原则

定义

happens-before原则是JMM中用来定义两个操作之间是否具有顺序性的规则。如果一个操作A happens-before 另一个操作B，那么A的结果对B是可见的。

常见的happens-before规则

程序顺序规则：在同一个线程中，按照代码的顺序执行。
锁规则：一个线程解锁操作 happens-before 另一个线程的加锁操作。
volatile变量规则：对volatile变量的写操作 happens-before 读操作。
线程启动规则：线程的启动操作 happens-before 线程中的任何操作。
线程终止规则：线程中的任何操作 happens-before 线程的终止操作。

举个例子

volatile int x = 0;

void thread1() {
    x = 1; // 写操作
}

void thread2() {
    if (x == 1) { // 读操作
        System.out.println("x is 1");
    }
}

在这个例子中，thread1对x的写操作 happens-before thread2对x的读操作，因为x是volatile变量，保证了可见性。

注意点：

在单线程环境中，指令重排序不会影响结果，但在多线程环境中可能导致问题。

6. JMM的总结

主内存与线程私有内存：主内存是所有线程共享的，线程私有内存是线程独有的。
可见性问题：线程对变量的修改可能不会立即反映到主内存中，导致其他线程看不到修改。
内存屏障：用于防止指令重排序，保证操作的顺序性。
volatile关键字：用于解决可见性问题，确保变量的读写操作直接在主内存中进行。
happens-before原则：定义了操作之间的顺序性，确保线程之间的操作结果是可见的。

7. 实际应用

使用`volatile`关键字

volatile int flag = 0;

void thread1() {
    flag = 1; // 写操作
}

void thread2() {
    while (flag == 0) { // 读操作
        // 等待flag变为1
    }
    System.out.println("flag is 1");
}

在这个例子中，flag是volatile变量，线程1对flag的写操作对线程2是可见的。

注意点：

volatile不能保证原子性。例如，volatile int count的count++操作不是线程安全的。

适用于状态标志（如boolean flag）或单次写入的场景。

使用锁

Object lock = new Object();
int count = 0;

void thread1() {
    synchronized (lock) {
        count++; // 修改共享变量
    }
}

void thread2() {
    synchronized (lock) {
        System.out.println(count); // 读取共享变量
    }
}

在这个例子中，通过锁确保了线程1对count的修改对线程2是可见的。