JMM（Java内存模型）

已于 2023-10-17 16:48:59 修改
阅读量416 收藏
点赞数
分类专栏： JMM Java内存模型 文章标签： java jvm
于 2021-04-06 09:00:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33507618/article/details/115428791
版权

JMM

一、CPU架构

在这里插入图片描述
现代计算机系统都加入了一层读写速度尽可能接近处理器运算速度的高速缓存（Cache）来作为内存与处理器之间的缓冲：将运算需要使用到的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存之中，这样处理器就无须等待缓慢的内存读写了。

基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但是也为计算机系统带来更高的复杂度，因为它引入了一个新的问题：缓存一致性（Cache Coherence）。（当多个处理器的运算任务都涉及同一块主内存区域时，将可能导致各自的缓存数据不一致）

缓存一致性

缓存一致性协议给缓存行（通常为64字节）定义了个状态，用来描述该缓存行是否被多处理器共享、是否修改，缓存一致性协议最出名的是MESI协议。

MESI中每个缓存行都有四个状态，分别是独占E（exclusive）、修改M（modified）、共享S（shared）、失效I（invalid）。

  • 独占（exclusive）：仅当前处理器拥有该缓存行，并且没有修改过，是最新的值。
  • 共享（share）：有多个处理器拥有该缓存行，每个处理器都没有修改过缓存，是最新的值。
  • 修改（modified）：仅当前处理器拥有该缓存行，并且缓存行被修改过了，一定时间内会写回主存，写成功状态会变为S。
  • 失效（invalid）：缓存行被其他处理器修改过，该值不是最新的值，需要读取主存上最新的值。

协议协作如下（仅作了解）：

  • 一个处于M状态的缓存行，必须时刻监听所有试图读取该缓存行对应的主存地址的操作，如果监听到，则必须在此操作执行前把其缓存行中的数据写回CPU。
  • 一个处于S状态的缓存行，必须时刻监听使该缓存行无效或者独享该缓存行的请求，如果监听到，则必须把其缓存行状态设置为I。
  • 一个处于E状态的缓存行，必须时刻监听其他试图读取该缓存行对应的主存地址的操作，如果监听到，则必须把其缓存行状态设置为S。当CPU需要读取数据时，如果其缓存行的状态是I的，则需要从内存中读取，并把自己状态变成S，如果不是I，则可以直接读取缓存中的值，但在此之前，必须要等待其他CPU的监听结果，如其他CPU也有该数据的缓存且状态是M，则需要等待其把缓存更新到内存之后，再读取。
    - 当CPU需要写数据时，只有在其缓存行是M或者E的时候才能执行，否则需要发出特殊的RFO指令(Read Or Ownership，这是一种总线事务)，通知其他CPU置缓存无效(I)，这种情况下会性能开销是相对较大的。在写入完成后，修改其缓存状态为M。

二、基础概念

CPU相关术语

术语英文单词术语描述
内存屏障Memorybarriers 是一组处理器指令，用于实现对内存操作的顺序执行
缓存行Cache line缓存中可以分配的最小存储单位

原子性、可见性、有序性

  • 原子性： read、load、use、assign、store、write、lock、unlock 8个汇编指令；
  • 可见性：一个线程操作的变量要对其他线程可见；
  • 有序性：线程内都是有序，线程内观察别的线程都是无序的。（单线程有序，多线程可能指令重排序）

synchronized关键字是通过monitorenter和monitorexit两个字节码指令来实现的，所以它具有原子性。

三、JMM模型

线程的工作内存其实是cpu寄存器和高速缓存的抽象，并不真实存在。

线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。

Java内存模型中规定了所有的变量都存储在主存中，每条线程还有自己的工作内存，线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，而不能直接读写主内存中的变量，不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来完成。
在这里插入图片描述

/**
 * 工作内存测试
 */
public class WorkCache {

    private static boolean initialization = false;

    /**
     * 主函数
     *
     * @param args 参数
     */
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            System.out.println("thread one start...");
            while (!initialization) {
            }
            System.out.println("thread one stop...");
        }).start();

        Thread.sleep(1000);

        new Thread(()->{
            System.out.println("thread two start...");
            init();
            System.out.println("thread two stop...");
        }).start();
    }

    public static void init() {
        initialization = true;
    }
}

结果：因为每个线程都有自己的工作内存，线程A对线程B的结果不可见，所以线程A一直没有结束。

thread one start...
thread two start...
thread two stop...

四、JMM内存分析

在这里插入图片描述

  1. read 读取：作用于主内存，把变量从主内存中读取到本地内存；
  2. load 加载：主要作用本地内存，把从主内存中读取的变量加载到本地内存的变量副本中；
  3. use 使用：主要作用本地内存，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作；
  4. assign 赋值：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作；
  5. store 存储：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作；
  6. write 写入：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中；
  7. lock 锁定：作用于主内存的变量，把一个变量标识为一条线程独占状态；
  8. unlock 解锁：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

五、指令重排

Java虚拟机内存模型允许编译器和处理器对指令重排序以提高运行性能，并且不会对存在数据依赖关系的操作做重排序（这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操作，多线程还是会指令重排序）。
在这里插入图片描述

  1. 编译器重排序：编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
  2. 指令级并行重排序：现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
  3. 内存系统重排序：由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

as-if-serial语义

单线程语义as-if-serial的意思指：不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不能被改变。但在多线程程序中，对存在控制依赖的操作重排序，可能会改变程序的执行结果。编译器、runtime和处理器都必须遵守as-if-serial语义。

在这里插入图片描述

as-if-serial语义把单线程程序保护了起来，遵守as-if-serial语义的编译器、runtime和处理器共同为编写单线程程序的程序员创建了一个幻觉：单线程程序是按程序的顺序来执行的。as-if-serial语义使单线程程序员无需担心重排序会干扰他们，也无需担心内存可见性问题。

import java.util.HashSet;
import java.util.Set;

/**
 * 重排序
 */
public class Rerank {

    static int x = 0, y = 0;
    static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        Set<String> set = new HashSet<>();
        for (int i = 0; i < 10000000; i++) {
            x = 0;
            y = 0;
            a = 0;
            b = 0;
            Thread one = new Thread(() -> {
                a = 1;
                x = b;
            });
            Thread two = new Thread(() -> {
                b = 1;
                y = a;
            });
            one.start();
            two.start();
            one.join();
            two.join();
            String key = x + "-" + y;
            if (!set.contains(key)) {
                set.add(key);
                System.out.println("(" + x + "," + y + ")");
            }
        }
    }
}

结果：多线程之间，数据依赖也会发生重排序，所以出现了4种结果。

(0,1)
(1,0)
(0,0)
(1,1)

Happen-before语义

JVM对代码进行编译优化，会出现指令重排序情况，为了避免编译优化对并发编程安全性的影响，需要happens-before规则定义一些禁止编译优化的场景，保证并发编程的正确性。

在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须要存在happens-before关系，这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。

注意：两个操作之间具有happens-before关系，并不意味着前一个操作必须要在后一个操作之前执行！happens-before仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前。

JMM和happens-before的关系

与程序员密切相关的happens-before规则如下。

  1. 程序顺序规则：一个线程中的每个操作，happens-before于该线程中的任意后续操作。
  2. 监视器锁规则：对一个锁的解锁，happens-before于随后对这个锁的加锁。
  3. volatile变量规则：对一个volatile域的写，happens-before于任意后续对这个volatile域的读。
  4. 传递性：如果A happens-before B，且B happens-before C，那么A happens-before C。

重排序对多线程的影响

class ReorderExample {
	int a = 0;
	boolean flag = false;
	public void writer() {
		a = 1; // 1
		flag = true; // 2
	}
	Public void reader() {
		if (f?lag) { // 3
			int i = a * a; // 4
			……
		}
	}
}

flag变量是个标记，用来标识变量a是否已被写入。这里假设有两个线程A和B，A首先执行writer()方法，随后B线程接着执行reader()方法。线程B在执行操作4时，能否看到线程A在操作1对共享变量a的写入呢？不一定能看到。

由于操作1和操作2没有数据依赖关系，编译器和处理器可以对这两个操作重排序；同样，操作3和操作4没有数据依赖关系，编译器和处理器也可以对这两个操作重排序。

操作1和操作2做了重排序。程序执行时，线程A首先写标记变量flag，随后线程B读这个变量。由于条件判断为真，线程B将读取变量a。此时，变量a还没有被线程A写入，在这里多线程程序的语义被重排序破坏了！

操作3和操作4存在控制依赖关系。当代码中存在控制依赖性时，会影响指令序列执行的并行度。为此，编译器和处理器会采用猜测（Speculation）执行来克服控制相关性对并行度的影响。以处理器的猜测执行为例，执行线程B的处理器可以提前读取并计算a*a，然后把
计算结果临时保存到一个名为重排序缓冲（Reorder Buffer，ROB）的硬件缓存中。当操作3的条件判断为真时，就把该计算结果写入变量i中。

在单线程程序中，对存在控制依赖的操作重排序，不会改变执行结果（这也是as-if-serial语义允许对存在控制依赖的操作做重排序的原因）；但在多线程程序中，对存在控制依赖的操作重排序，可能会改变程序的执行结果。

六、内存屏障

为了保证内存可见性，Java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。

在多核CPU的情况下，因为多核CPU上的指令同时执行，如果涉及到共享变量的修改，这种优化会影响多线程运行的正确性，而内存屏障是硬件层面提供的一系列特殊指令，当CPU处理到这些指定时，会做一些特殊的处理，可以使处理器内的内存状态对其它处理器可见，在不同的平台上支持的内存屏障也会有差异。

  1. 阻止屏障两侧的指令重排序；
  2. 强制把写缓冲区/高速缓存中的脏数据等写回主内存，让缓存中相应的数据失效。

在JSR规范中定义了4种内存屏障：

屏障类型伪代码说明
LoadLoad屏障Load1; LoadLoad; Load2在Load2及后续读取操作要读取的数据被访问前，保证Load1要读取的数据被读取完毕
LoadStore屏障Load1; LoadStore; Store2在Store2及后续写入操作被刷出前，保证Load1要读取的数据被读取完毕
StoreStore屏障Store1; StoreStore; Store2在Store2及后续写入操作执行前，保证Store1的写入操作对其它处理器可见
StoreLoad屏障Store1; StoreLoad; Load2在Load2及后续所有读取操作执行前，保证Store1的写入对所有处理器可见

为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。代码如下：

/**
 * volatile保证可见性
 */
public class Visible {
    private static volatile boolean initialization = false;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            System.out.println("thread one start...");
            while (!initialization) {
            }
            System.out.println("thread one stop...");
        }).start();

        Thread.sleep(1000);

        new Thread(()->{
            System.out.println("thread two start...");
            init();
            System.out.println("thread two stop...");
        }).start();
    }

    public static void init() {
        initialization = true;
    }
}

结果：

thread one start...
thread two start...
thread two stop...
thread one stop...

内存屏障的实现

源代码：

inline void OrderAccess::loadload() { compiler_barrier(); }
inline void OrderAccess::storestore() { compiler_barrier(); }
inline void OrderAccess::loadstore() { compiler_barrier(); }
inline void OrderAccess::storeload() { fence(); }
inline void OrderAccess::acquire() { compiler_barrier(); }
inline void OrderAccess::release() { compiler_barrier(); }
inline void OrderAccess::fence() {
// always use locked addl since mfence is sometimes 
expensive
#ifdef AMD64
__asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", 
"memory");
#else
__asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", 
"memory");
#endif
compiler_barrier();
}

volatile可见性的实现

有volatile变量修饰的共享变量进行写操作的时候会使用CPU提供的Lock前缀指令：

  • 将当前处理器缓存行的数据写回到系统内存；
  • 这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效。
if (cache->is_volatile()) {
	switch (tos_type) {
		case ztos:
			obj->release_byte_field_put(field_offset, (STACK_INT(-1) & 1)); // only store LSB
			break;
		………….. 
}
		default:
		ShouldNotReachHere();
	}
	OrderAccess::storeload();
}

七、可见性内存分析

在这里插入图片描述
如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。

八、重识双检锁

/**
 * 双重检查单例
 */
public class DclSingleton {
    private static DclSingleton instance; // 这里没有volatile，instance = new DclSingleton();可能发生重排序而产生多个对象
    public static DclSingleton getInstance() {
        if (null == instance) {
            synchronized (DclSingleton.class) {
                if (null == instance) {
                    instance = new DclSingleton();
                }	
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        DclSingleton.getInstance();
    }
}

memory = allocate(); // 1：分配对象的内存空间
ctorInstance(memory); // 2：初始化对象
instance = memory; // 3：设置instance指向刚分配的内存地址

重排序后：

memory = allocate(); // 1：分配对象的内存空间
instance = memory; // 3：设置instance指向刚分配的内存地址， 注意，此时对象还没有被初始化！
ctorInstance(memory); // 2：初始化对象

九、CAS

独占锁是一种悲观锁，synchronized就是一种独占锁，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。

而另一个更加有效的锁就是乐观锁，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。


import java.util.ArrayList;
import java.util.List;

/**
 * 计数器
 */
public class Counter {

    private static volatile int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            threadList.add(new Thread(() -> {
                for (int k = 0; k < 10000; k++) {
                    counter++;
                }
            }));
        }
        for (Thread thread : threadList) {
            thread.start();
        }
        for (Thread thread : threadList) {
            thread.join();
        }
        System.out.println(counter);
    }
}

结果可能有很多种：

173576

atomic包

使用循环CAS实现原子操作

JVM中的CAS操作正是利用了处理器提供的CMPXCHG指令实现的。自旋CAS实现的基本思路就是循环进行CAS操作直到成功为止，以下代码实现了一个基于CAS线程安全的计数器。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 计数器
 */
public class SafeCounter {

    private static AtomicInteger counter = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            threadList.add(new Thread(() -> {
                for (int k = 0; k < 10000; k++) {
                	// 手动实现自旋锁
                    while(true) {
                        int count = counter.get();
                        boolean success = counter.compareAndSet(count, count + 1);
                        if (success) {
                            break;
                        }
                    }
                }
            }));
        }
        for (Thread thread : threadList) {
            thread.start();
        }
        for (Thread thread : threadList) {
            thread.join();
        }
        System.out.println(counter.get());
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 计数器
 */
public class SafeCounter1 {

    private static AtomicInteger counter = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            threadList.add(new Thread(() -> {
                for (int k = 0; k < 10000; k++) {
                	// 源码实现自旋锁
                    counter.getAndIncrement();
                }
            }));
        }
        for (Thread thread : threadList) {
            thread.start();
        }
        for (Thread thread : threadList) {
            thread.join();
        }
        System.out.println(counter.get());
    }
}


// 源码
public final int getAndAddInt(Object var1, long var2, int var4) {
   int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}
抽抽了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
简述Java内存模型(JMM)
王壮zhuang的博客
05-10 819
现代计算机模型与缓存一致性 现代计算机模型 现代计算机模型是基于冯诺依曼计算机模型，这里解释一下他的主要理论： 程序与数据一样存贮，按程序编排的顺序，一步一步地取出指令，自动地完成指令规定的操作是计算机最基本的工作模型。也就是说计算机再运行时，先从内存中取出一条指令(这里的内存可以理解为计算机的运行内存，也就是内存条)，通过控制器的译码，按照指令要求，从存储器取出数据进行运算和逻辑操作，然后将结果写入内存中，然后反复这些操作。 上图就是冯诺依曼计算机模型。这里的存储器就是内存条，...
JMM：Java内存模型
洲哥的博客
10-10 180
1.什么是 JMM JMM 全称是 Java Memory Model. 导致可见性问题的根本原因是缓存以及重排序。JMM 实际上就是提供了合理的禁用缓存以及禁止重排序的方法。所以它最核心的价值在于解决可见性和有序性。 JMM 属于语言级别的抽象内存模型，可以简单理解为对硬件模型的抽象，它定义了共享内存中多线程程序读写操作 的行为规范：在虚拟机中把共享变量存储到内存以及从内存中取出共享变量的底...
深入理解JMM(Java内存模型)
老猫喜欢今日爬山的博客
11-15 122
Java内存模型(Java Memory Model简称JMM)是一种抽象的概念，并不真实存在，它描述的一组规则或者规范。通过这些规则、规范定义了程序中各个变量的访问方式。jvm运行的程序的实体是线程，而每个线程运行时，都会创建一个工作内存（也叫栈空间），来保存线程所有的私有变量。而JMM内存模型规范中规定所有的变量都存储在主内存中，而主内存中的变量是所有的线程都可以共享的，而对主内存中的变量进行操作时，必须在线程的工作内存进行操作，首先将主内存的变量copy到工作内存，进行操作后，再将变量刷回到主内存中。
JMM内存模型图
05-07
Java运行时内存模型图
Java内存模型（JMM）详解
最新发布
一个喜欢诗和远方的程序媛
06-18 926
Java内存模型（JMM）提供了一组规则，确保多线程程序在不同平台上的一致性和正确性。通过理解JMM的核心概念、关键字和同步机制以及 happens-before 规则，开发者可以编写出高效且线程安全的并发程序。
JMM内存模型
yygr的博客
01-17 2995
Java内存模型即Java Memory Model，简称JMM。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。 如果我们要想深入了解Java并发编程，就要先理解好Java内存模型。Java内存模型定义了多线程之间共享变量的可见性以及如何在需要的时候对共享变量进行同步。原始的Java内存模型效率并不是很理想，因此Java1.5版本对其进行了重构，现在的Java8仍沿用了Java1.5的版本。 关于并发编程 在并发编程领域，有
JMM（Java 内存模型）详解
m0_51431003的博客
11-12 6038
所有线程创建的实例对象都存放在主内存中，不管该实例对象是成员变量还是方法中的本地变量(也称局部变量)每个线程都有一个私有的本地内存来存储共享变量的副本，并且，每个线程只能访问自己的本地内存，无法访问其他线程的本地内存。本地内存是 JMM 抽象出来的一个概念，存储了主内存中的共享变量副本。线程 A 把本地内存中修改过的共享变量副本的值同步到主内存中去。线程 B到主存中读取对应的共享变量的值。也就是说，JMM 为共享变量提供了可见性的保障。
JMM（Java内存模型）详解
热门推荐
LYQ20010417的博客
04-13 3万+
1.什么是JMM？ ​ JMM 是Java内存模型（ Java Memory Model），简称JMM。它本身只是一个抽象的概念，并不真实存在，它描述的是一种规则或规范。通过这组规范，定义了程序中对各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。 ​ 计算机在执行程序时，每条指令都是在CPU中执行的。而执行指令的过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过
Java内存模型JMM浅析
02-25
并发编程有多种风格，除了CSP(通信顺序进程)、Actor等模型外，大家最熟悉的应该是基于线程和锁的共享内存模型了。在多线程编程中，需要注意三类并发问题:1.原子性2.可见性3.重排序原子性涉及到，一个线程执行一个...
Java内存模型详解JMM.docx
05-03
Java内存模型详解JMM Java内存模型（Java Memory Model，JMM）是Java虚拟机（JVM）中的一种内存模型，它描述了程序中各个变量之间的关系，以及在实际计算机系统中将变量存储到内存和从内存中取出变量这样的底层细节...
学习Java内存模型JMM心得
08-28
Java内存模型JMM心得 Java内存模型（JMM）是Java虚拟机规范中的一部分，对Java编程语言的内存模型进行了抽象，解决了编译器和处理器的优化对多线程程序的影响。JMM的主要目标是提供一个在多线程环境下正确的内存...
【Java内存模型】Java内存模型（JMM）详解以及并发编程的三个重要特性（原子性，可见性，有序性）
小七的博客
02-14 2823
目录 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...
JVM 虚拟机 ----＞ Java 内存模型（JMM）
weixin_62587914的博客
09-12 2125
Heap堆区，用于存放对象实例和数组的内存区域Heap堆是JVM所管理的内存中最大的一块区域，被所有线程共享的一块内存区域。堆区中存放对象实例，“几乎”所有的对象实例以及数组都在这里分配内存Java世界中“几乎”所有的对象都在堆中分配，但是，随着JIT编译器的发展与逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化，所有的对象都分配到堆上也渐渐变得不那么“绝对”了。从JDK 1.7。
Java 内存模型(JMM)
半夏_2021的博客
08-11 3418
文章目录什么是JMM模型JMM和JVM的区别主内存和工作内存Java内存模型与硬件内存架构的关系JMM存在的必要性 什么是JMM模型 Java内存模型(Java Memory Model简称JMM)是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。 JVM运行程序的实体是线程，而每个线程创建时,JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据。 Java内存模型中规定所有变量都存储在
一文读懂Java内存模型(JMM)及volatile关键字
org_hjh的博客
11-10 379
点赞再看，养成习惯，公众号搜一搜【一角钱技术】关注更多原创技术文章。 本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。 前言 并发编程从操作系统底层工作的整体认识开始 上一篇我们从操作系统底层工作的整体了解了并发编程在硬件以及操作系统层面的一些知识，本篇我们继续来学习JMM模型以及Volatile关键字的那些面试必问的一些知识点。 什么是JMM模型？ Java 内存模型（Java Memory Model 简称JMM）是一种抽象的概念，并不真实存在，它描..
全面理解JMM模型
林木森的博客
11-04 4402
一、什么是JMM模型 Java内存模型(即Java Memory Model，简称JMM)本身是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据，而Java内存模型中规定所有变...
JMM内存模型详解
全栈行动派的博客
04-11 887
JVM规范试图定义一种Java内存模型（JMM）来屏蔽各种硬件和操作系统的内存访问模型。关键技术点都是围绕多线程的原子性、可见性和有序性这三大特性展开的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

抽抽了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值