JAVA中的JMM（Java 内存模型）详解

已于 2024-08-26 22:52:11 修改
阅读量1.5k 收藏 18
点赞数 40
分类专栏： JAVA的基础知识 文章标签： java 开发语言
于 2024-08-05 12:07:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79993788/article/details/140892212
版权

1.JMM概念

Java 内存模型（Java Memory Model 简称JMM）是一种抽象的概念，并不真实存在，指一组规则或规范，通过这组规范定义了程序中各个变量的访问方式。

因为在不同的硬件生产商和不同的操作系统下，内存的访问有一定的差异，所以会造成相同的代码运行在不同的系统上会出现各种问题。java内存模型(JMM)屏蔽掉各种硬件和操作系统的内存访问差异，以实现让java程序在各种平台下都能达到一致的并发效果。

结构

JAVA内存模型

54df3f5f715542028e65950dfd6e72b9.png

也就是说，在栈中的变量（局部变量、方法定义的参数、异常处理的参数）不会在线程之间共享，也就不会有内存可见性的问题，也不受内存模型的影响。而在堆中的变量是共享的，一般称之为共享变量。

所以，内存可见性针对的是堆中的共享变量。

内存可见性问题是如何发生的？

那可能就有小伙伴会问：既然堆是共享的，为什么在堆中会有内存不可见问题？

 

这是因为现代计算机为了高效，往往会在高速缓存区中缓存共享变量，因为 CPU 访问缓存区比访问内存要快得多。

什么是主内存？什么是本地内存？

  • 主内存：所有线程创建的实例对象都存放在主内存中，不管该实例对象是成员变量，还是局部变量，类信息、常量、静态变量都是放在主内存中。为了获取更好的运行速度，虚拟机及硬件系统可能会让工作内存优先存储于寄存器和高速缓存中。
  • 本地内存：每个线程都有一个私有的本地内存，本地内存存储了该线程以读 / 写共享变量的副本。每个线程只能操作自己本地内存中的变量，无法直接访问其他线程的本地内存。如果线程间需要通信，必须通过主内存来进行。本地内存是 JMM 抽象出来的一个概念，并不真实存在，它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。

2695d6007ab141dca2ae26cf889c75b4.png

从图中可以看出：

  1. 所有的共享变量都存在主存中。
  2. 每个线程都保存了一份该线程使用到的共享变量的副本。
  3. 如果线程 A 与线程 B 之间要通信的话，必须经历下面 2 个步骤：
  4. 线程 A 将本地内存 A 中更新过的共享变量刷新到主存中去。
  5. 线程 B 到主存中去读取线程 A 之前已经更新过的共享变量。

所以，线程 A 无法直接访问线程 B 的工作内存，线程间通信必须经过主存。

注意，根据 JMM 的规定，线程对共享变量的所有操作都必须在自己的本地内存中进行，不能直接从主存中读取。 c307594e792348a7917758437dcc4d40.png

所以线程 B 并不是直接去主存中读取共享变量的值，而是先在本地内存 B 中找到这个共享变量，发现这个共享变量已经被更新了，然后本地内存 B 去主存中读取这个共享变量的新值，并拷贝到本地内存 B 中，最后线程 B 再读取本地内存 B 中的新值。 

2.Java 内存区域和 JMM 有何区别？        

  • 区别

    两者是不同的概念。JMM 是抽象的，他是用来描述一组规则，通过这个规则来控制各个变量的访问方式，围绕原子性、有序性、可见性等展开。而 Java 运行时内存的划分是具体的，是 JVM 运行 Java 程序时必要的内存划分。

  • 联系

    都存在私有数据区域和共享数据区域。一般来说，JMM 中的主存属于共享数据区域，包含了堆和方法区；同样，JMM 中的本地内存属于私有数据区域，包含了程序计数器、本地方法栈、虚拟机栈。 

总结：

  • 方法区：存储了每一个类的结构信息，如运行时常量池、字段和方法数据、构造方法和普通方法的字节码内容。
  • 堆：几乎所有的对象实例以及数组都在这里分配内存。这是 Java 内存管理的主要区域。
  • 栈：每一个线程有一个私有的栈，每一次方法调用都会创建一个新的栈帧，用于存储局部变量、操作数栈、动态链接、方法出口等信息。所有的栈帧都是在方法调用和方法执行完成之后创建和销毁的。
  • 本地方法栈：与栈类似，不过本地方法栈为 JVM 使用到的 native方法服务。
  • 程序计数器：每个线程都有一个独立的程序计数器，用于指示当前线程执行到了字节码的哪一行。 

处理器重排序与内存屏障指令

前面提到了，JMM 定义了多线程之间如何互相交互的规则，主要目的是为了解决由于编译器优化、处理器优化和缓存系统等导致的可见性、原子性和有序性。

那我们接下来就来聊聊重排序以及它所带来的顺序问题。

为什么指令重排可以提高性能？

大家都知道，计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排。

那可能有小伙伴就要问：为什么指令重排序可以提高性能？

简单地说，每一个指令都会包含多个步骤，每个步骤可能使用不同的硬件。因此，流水线技术产生了，它的原理是指令 1 还没有执行完，就可以开始执行指令 2，而不用等到指令 1 执行结束后再执行指令 2，这样就大大提高了效率。

但是，流水线技术最害怕中断，恢复中断的代价是比较大的，所以我们要想尽办法不让流水线中断。指令重排就是减少中断的一种技术。

我们分析一下下面这段代码的执行情况：

a = b + c;
d = e - f ;

先加载 b、c（注意，有可能先加载 b，也有可能先加载 c），但是在执行 add(b,c) 的时候，需要等待 b、c 装载结束才能继续执行，也就是需要增加停顿，那么后面的指令（加载 e 和 f）也会有停顿，这就降低了计算机的执行效率。

为了减少停顿，我们可以在加载完 b 和 c 后把 e 和 f 也加载了，然后再去执行 add(b,c)，这样做对程序（串行）是没有影响的，但却减少了停顿。

换句话说，既然 add(b,c) 需要停顿，那还不如去做一些有意义的事情（加载 e 和 f）。

综上所述，指令重排对于提高 CPU 性能十分必要，但也带来了乱序的问题。

现代的处理器使用写缓冲区来临时保存向内存写入的数据。写缓冲区可以保证指令流水线持续运行，它可以避免由于处理器停顿下来等待向内存写入数据而产生的延迟。同时，通过以批处理的方式刷新写缓冲区，以及合并写缓冲区中对同一内存地址的多次写，可以减少对内存总线的占用。虽然写缓冲区有这么多好处，但每个处理器上的写缓冲区，仅仅对它所在的处理器可见。这个特性会对内存操作的执行顺序产生重要的影响：处理器对内存的读 / 写操作的执行顺序，不一定与内存实际发生的读 / 写操作顺序一致！为了具体说明，请看下面示例：

// Processor A
a = 1; //A1  
x = b; //A2

// Processor B
b = 2; //B1  
y = a; //B2

// 初始状态：a = b = 0；处理器允许执行后得到结果：x = y = 0

7ca812f48fae4601a216848c9a99ef14.png

这里处理器 A 和处理器 B 可以同时把共享变量写入自己的写缓冲区（A1，B1），然后从内存中读取另一个共享变量（A2，B2），最后才把自己写缓存区中保存的脏数据刷新到内存中（A3，B3）。当以这种时序执行时，程序就可以得到 x = y = 0 的结果。

从内存操作实际发生的顺序来看，直到处理器 A 执行 A3 来刷新自己的写缓存区，写操作 A1 才算真正执行了。虽然处理器 A 执行内存操作的顺序为：A1->A2，但内存操作实际发生的顺序却是：A2->A1。此时，处理器 A 的内存操作顺序被重排序了（处理器 B 的情况和处理器 A 一样，这里就不赘述了）。

这里的关键是，由于写缓冲区仅对自己的处理器可见，它会导致处理器执行内存操作的顺序可能会与内存实际的操作执行顺序不一致。由于现代的处理器都会使用写缓冲区，因此现代的处理器都会允许对写 - 读操做重排序。

重排序有哪几种？

指令重排一般分为以下三种：

  • 编译器优化重排，编译器在不改变单线程程序语义的前提下，重新安排语句的执行顺序。

  • 指令并行重排，现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性(即后一个执行的语句无需依赖前面执行的语句的结果)，处理器可以改变语句对应的机器指令的执行顺序。

  • 内存系统重排，由于处理器使用缓存和读写缓存冲区，这使得加载(load)和存储(store)操作看上去可能是在乱序执行，因为三级缓存的存在，导致内存与缓存的数据同步存在时间差。

代码举例： 

编译器优化重排：

int a = 1;
int b = 2;
System.out.println(a);
System.out.println(b);

尽管在代码中，我们首先赋值给a，然后赋值给b，最后打印这两个变量，但编译器可能会重排这些语句，因为它们之间没有数据依赖性。编译器可能会这样优化代码：

int b = 2; // 编译器可能首先执行这一行
int a = 1; // 然后执行这一行
System.out.println(b); // 打印b
System.out.println(a); // 打印a

 指令并行重排示例：

int x = 1;
int y = x + 1;
System.out.println(y);

在这个例子中，y的值依赖于x的值。然而，如果编译器认为x的值不会改变，它可能会将System.out.println(y)提前执行，因为y的计算可以与打印操作并行执行：

int x = 1;
System.out.println(y); // 可能被提前执行
int y = x + 1; // 尽管y依赖x，但编译器可能认为可以并行执行

内存系统重排示例：

double pi = 3.14159;
System.out.println(pi);

 在这个例子中，我们首先将pi的值赋值为3.14159，然后打印它。然而，由于处理器使用缓存，pi的值可能首先被加载到寄存器或一级缓存中，然后才被打印。这个加载操作和打印操作可能会在不同的时间点执行，导致乱序执行：

// 假设pi的值首先被加载到缓存
double cachedPi = loadFromCache(pi); // 这可能在打印之前发生

// 然后执行打印操作
System.out.println(pi); // 这可能在加载操作之后发生

指令重排可以保证串行语义一致，但是没有义务保证多线程间的语义也一致。所以在多线程下，指令重排序可能会导致一些问题。

JMM与顺序一致性模型

当程序未正确同步的时候，就可能存在数据竞争。

数据竞争：在一个线程中写一个变量，在另一个线程读同一个变量，并且写和读没有通过同步来排序。

如果程序中包含了数据竞争，那么运行的结果往往充满了不确定性，比如读发生在了写之前，可能就会读到错误的值；如果一个线程能够正确同步，那么就不存在数据竞争。

Java 内存模型（JMM）对于正确同步多线程程序的内存一致性做了以下保证：如果程序是正确同步的，程序的执行将具有顺序一致性。即程序的执行结果和该程序在顺序一致性模型中执行的结果相同。因为他要求更多的同步和内存保障，所以这种模型会浪费一些性能

这里的同步包括使用 volatile、final、synchronized 等关键字实现的同步。

如果我们开发者没有正确使用volatile、final、synchronized 等关键字，那么即便是使用了同步，JMM 也不会有内存可见性的保证，很可能会导致程序出错，并且不可重现，很难排查。

顺序一致性内存

顺序一致性模型是一个理想化的理论参考模型，它为程序提供了极强的内存可见性保证。顺序一致性模型有两大特性：

  • 一个线程中的所有操作必须按照程序的顺序（即 Java 代码的顺序）来执行。
  • 不管程序是否同步，所有线程都只能看到一个单一的操作执行顺序。即在顺序一致性模型中，每个操作必须是原子性的，且立刻对所有线程可见。

为了理解这两个特性，我们举个例子，假设有两个线程 A 和 B 并发执行，线程 A 有 3 个操作，他们在程序中的顺序是 A1->A2->A3，线程 B 也有 3 个操作，B1->B2->B3。

假设正确使用了同步，A 线程的 3 个操作执行后释放锁，B 线程获取同一个锁。那么在顺序一致性模型中的执行效果如下所示：

 

273faa9ab3708684a8a259f6c7d13b32.png

操作的执行整体上有序，并且两个线程都只能看到这个执行顺序。629c3f0a87604f9a834288cbbd493b15.png

未同步程序在顺序一致性模型中虽然整体执行顺序是无序的，但所有线程都只能看到一个一致的整体执行顺序。以上图为例，线程 A 和 B 看到的执行顺序都是：B1->A1->A2->B2->A3->B3。之所以能得到这个保证是因为顺序一致性内存模型中的每个操作必须立即对任意线程可见。

但是，在 JMM 中就没有这个保证。未同步程序在 JMM 中不但整体的执行顺序是无序的，而且所有线程看到的操作执行顺序也可能不一致。比如，在当前线程把写过的数据缓存在本地内存中，且还没有刷新到主内存之前，这个写操作仅对当前线程可见；从其他线程的角度来观察，会认为这个写操作根本还没有被当前线程执行。只有当前线程把本地内存中写过的数据刷新到主内存之后，这个写操作才能对其他线程可见。在这种情况下，当前线程和其它线程看到的操作执行顺序将不一致。

同步程序的顺序一致性效果

class SynchronizedExample {
    int a = 0;
    boolean flag = false;

    public synchronized void writer() {
        a = 1;
        flag = true;
    }

    public synchronized void reader() {
        if (flag) {
            int i = a;
            ……
        }
    }

 上面示例代码中，假设 A 线程执行 writer() 方法后，B 线程执行 reader() 方法。这是一个正确同步的多线程程序。根据 JMM 规范，该程序的执行结果将与该程序在顺序一致性模型中的执行结果相同。下面是该程序在两个内存模型中的执行时序对比图：

      796337c9037746ec8d07ded4fa188f82.png

从这里我们可以看到 JMM 在具体实现上的基本方针：在不改变（正确同步的）程序执行结果的前提下，尽可能的为编译器和处理器的优化打开方便之门。 

JMM和happens-before

Happens-Before原则是JMM中用于定义操作之间偏序关系的一个原则。根据这个原则，如果一个操作A happens-before另一个操作B，那么A的结果对B可见，即B能够看到A对共享变量所做的修改。Happens-Before原则是保证多线程程序内存一致性的关键机制之一。

 happens-before 关系的定义如下：

  1. 如果一个操作 happens-before 另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。
  2. 两个操作之间存在 happens-before 关系，并不意味着 Java 平台的具体实现必须要按照 happens-before 关系指定的顺序来执行。如果重排序之后的执行结果，与按 happens-before 关系来执行的结果一致，那么 JMM 也允许这样的重排序。

happens-before 关系本质上和 as-if-serial 语义是一回事。

as-if-serial 语义保证单线程内重排序后的执行结果和程序代码本身应有的结果是一致的，happens-before 关系保证正确同步的多线程程序的执行结果不被重排序改变。

 as-if-serial 语义示例

假设我们有一个简单的单线程程序，如下所示：

int a = 1; // A
int b = 2; // B
int c = a + b; // C

根据as-if-serial语义，即使编译器和处理器将A和B重排序，最终执行的结果应该与上述代码顺序执行的结果一致。例如，它们可以重排序为：

int a = 1; // A
int c = 3; // C
int b = 2; // B (尽管B被重排序到C之后，但这不影响最终结果)

因为最终`c`的值仍然是3，与原始代码顺序执行的结果一致。

 happens-before 语义示例

class Counter {
    private volatile int count = 0;

    public void increment() {
        count++; // A
    }

    public int getCount() {
        return count; // B
    }
}

Counter counter = new Counter();

Thread t1 = new Thread(counter::increment);
Thread t2 = new Thread(() -> {
    while (counter.getCount() == 0) ; // C
});

t1.start();
t2.start();

- 操作A（`count++`）对操作B（`return count`）是可见的，因为`count`是`volatile`变量，根据`volatile`变量规则，对`volatile`变量的写操作happens-before于后续对该变量的读操作。

- 操作C（循环检查`count`）happens-before于操作B，因为C是一个循环，它在B之前执行，并且B依赖于C的结果来退出循环。

 

即使编译器和处理器可能会对A和C进行重排序，它们必须保证重排序后的执行结果与按照happens-before关系顺序执行的结果一致。例如，它们不能将C重排序到A之前，因为这将破坏内存一致性。

class SafeCounter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++; // D
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count; // E
        }
    }
}

SafeCounter counter = new SafeCounter();

Thread t1 = new Thread(counter::increment);
Thread t2 = new Thread(() -> {
    int result = counter.getCount(); // F
    System.out.println(result);
});

t1.start();
t2.start();

在这个例子中：

- 操作D（`count++`）在监视器锁的保护下，因此它happens-before于操作E（`return count`），因为它们被同一个锁`lock`保护。

- 即使编译器和处理器可能会对D和E进行重排序，它们必须保证重排序后的执行结果与按照happens-before关系顺序执行的结果一致，以保证内存一致性。

 

通过这些示例，我们可以看到`as-if-serial`和`happens-before`语义如何在Java程序中确保单线程和多线程环境下的执行结果的一致性。

总之，如果操作 A happens-before 操作 B，那么操作 A 在内存上所做的操作对操作 B 都是可见的，不管它们在不在一个线程。

 

 

倾城璧
关注
专栏目录
Java并发：Java内存模型（JMM）与线程
程序员囧辉
12-31 3930
概述多任务处理在现代计算机操作系统中几乎已是一项必备的功能了。在许多情况下，让计算机同时去做几件事情，不仅是因为计算机的运算能力强大了，还有一个很重要的原因是计算机的运算速度与它的存储和通信子系统速度的差距太大，大量的时间都花费在磁盘I/O、网络通信或者数据库访问上。如果不希望处理器在大部分时间里都处于等待其他资源的状态，就必须使用一些手段去把处理器的运算能力“压榨”出来，否则就会造成很大的浪费，...
Java内存模型(Java Memory Model，JMM)
2401_83817171的博客
04-17 630
关于面试刷题也是有方法可言的，建议最好是按照专题来进行，然后由基础到高级，由浅入深来，效果会更好。Java基础部分算法与编程数据库部分流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。
Java 内存模型 (JMM)
最新发布
pjx987的博客
09-18 973
Java 内存模型是 Java 多线程编程的基础，理解其核心概念和原则对于编写高效、可靠的并发程序至关重要。通过合理使用volatile和并发工具类，可以有效解决多线程环境下的可见性、原子性和有序性问题。希望本文能帮助你更好地掌握 Java 内存模型，提升你的多线程编程能力。
12.Java内存模型
热门推荐
风中的索莉逖亚
10-13 2万+
（原本准备把内存模型单独放到某一篇文章的某个章节里面讲解，后来查阅了国外很多文档才发现其实JVM内存模型的内容还蛮多的，所以直接作为一个章节的基础知识来讲解，可能该章节概念的东西比较多。一个开发Java的开发者，一旦了解了JVM内存模型就能够更加深入地了解该语言的语言特性，可能这个章节更多的是概念，没有太多代码实例，所以希望读者谅解，有什么笔误来Email告知：silentbalanceyh@12
深入理解Java内存模型
zgmzyr的专栏
04-13 6503
转载于：http://www.infoq.com/cn/articles/java-memory-model-1?utm_source=infoq&utm_medium=related_content_link&utm_campaign=relatedContent_articles_clk 深入理解Java内存模型（一）——基础 并发编程模型的分类 在并
Java内存模型（JMM）
枫陵的博客
04-29 387
一. JMM的定义 JMM(Java内存模型 Java Memory Model,简称JMM)本身是一种抽象的概念并不真实存在它仅仅描述的是一组约定或规范，通过这组规范定义了程序中(尤其是多线程)各个变量的读写访问方式并决定一个线程对共享变量的写入以及如何变成对另一个线程可见，关键技术点都是围绕多线程的原子性、可见性和有序性展开的原则: JMM的关键技术点都是围绕多线程的原子性、可见性和有序性展开的作用：1 通过JMM来实现线程和主内存之间的抽象关系。...
Java内存模型之JMM
散步的博客
04-08 220
计算机硬件存储体系: 计算机存储结构，从本地磁盘到主存到CPU缓存，也就是从硬盘到内存，到CPU。 一般对应的程序的操作就是从数据库查数据到内存然后到CPU进行计算 因为有这么多级的缓存(cpu和物理主内存的速度不一致的)， CPU的运行并不是直接操作内存而是先把内存里边的数据读到缓存，而内存的读和写操作的时候就会造成不一致的问题 Java虚拟机规范中试图定义一种Java内存模型（java Memory Model，简称JMM) 来屏蔽掉各种硬件和操作系统的内存访问差异， 以实现让Java程序在各种平台下
Java内存模型详解JMM.docx
05-03
Java内存模型详解JMM Java内存模型（Java Memory Model，JMM）是Java虚拟机（JVM）中的一种内存模型，它描述了程序中各个变量之间的关系，以及在实际计算机系统中将变量存储到内存和从内存中取出变量这样的底层细节...
Java内存模型JMM详解
08-28
主要介绍了Java内存模型JMM详解，涉及volatile和监视器锁，final字段，内存屏障等相关内容，具有一定参考价值，需要的朋友可以了解下。
JMM(Java 内存模型详解)
02-19
Java开发
【JVM】JVM08(java内存模型解析[JMM])_java 8 jvm内存模式
2301_82241775的博客
04-20 1125
在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）
Java并发编程—JMM（Java内存模型）在并发中的原理与应用
kkkllllss的博客
03-19 663
1. JVM内存结构、Java内存模型与Java对象模型 辨析 1.1 JVM内存结构 JVM内存结构详解请看：认识JVM的内存布局和运行时数据区 JVM内存结构，也可以称作JVM运行时内存，这个和我们代码执行在JVM上使用内存有关。 1.2 Java内存模型 Java内存模型则是和并发编程相关。后面会仔细说明 1.3 Java对象模型 Java对象模型是指Java对象在虚拟机中的表现形式。 Java对象模型是对象自身的存储结构 JVM会给类创建一个instanceKlass保
【Java内存模型】Java内存模型（JMM）详解以及并发编程的三个重要特性（原子性，可见性，有序性）
小七的博客
02-14 3875
目录 1 Java内存模型（Java memory model JMM） 1.1 什么是JMM（JMM的作用） 1.2 JMM的组成 2 硬件内存架构与java内存模型 2.1 硬件架构 2.2 Java线程与硬件处理器 2.3 Java内存模型与硬件内存架构的关系 2.4 Java内存模型的必要性 3.并发编程的三个重要特性 3.1 原子性 3.2 可见性 3.3...
JMM(Java内存模型)详解
落日的博客
07-03 3465
为了对上面的问题进行更深入的探究，我有查了一些JIT相关的资料。简单总结下JIT然后再对上面的问题分析下。JIT（Just-In-Time）编译器是Java虚拟机（JVM）中的一个关键组件，它负责在程序运行过程中动态地将字节码（即Java编译后的.class文件中的代码）转换为特定于平台的机器代码。这一过程旨在提高程序的执行效率，因为它能够针对运行时的数据和实际使用模式进行优化，而不仅仅是基于静态代码分析。JIT工作原理加载与解释执行：当Java程序启动时，JVM首先加载类文件并由解释器执行字节码。
Java内存模型—JMM详解
可达鸭的博客
07-23 3357
JMM
【java】Java JMM（内存模型）
DreamSun的博客
02-27 384
在并发编程中，当多个线程同时访问同一个共享的可变变量时，会产生不确定的结果，所以要编写线程安全的代码，其本质上是对这些可变的共享变量的访问操作进行管理。导致这种不确定结果的原因就是可见性、有序性和原子性问题，Java 为解决可见性和有序性问题引入了 Java 内存模型，使用互斥方案（其核心实现技术是锁）来解决原子性问题。这篇先来看看解决可见性、有序性问题的 Java 内存模型（JMM）。
java jmm
kjfcpua的专栏
01-05 2906
1.什么是JMM？     JMM即Java Memory Model，设想有这样一条赋值语句：int a = 1;而a为诸多线程所共享， JMM所关注的问题就是：“读取a的线程在何时会看到值为1的这个写入？” 2. 为什么关注JMM？     在多数情况下，即使是并发程序的程序员，也并不特别关心JMM，因为Java语言与JVM用更高抽象的“同步”语义隐藏了JMM的语义，使得程序
深入理解Java内存模型：JMM详解
"Java内存模型是Java开发中的关键概念，它描述了程序中变量如何在内存中存储和访问，特别是涉及多线程环境下的同步和线程安全性。JVM内存模型，也称为JMM（Java Memory Model），是Java平台的核心组成部分，确保了在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值