Java 内存模型JMM详解

春来桃花开 春来桃花开 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 600+累计阅读 621平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 最新推荐文章于 2026-07-29 15:13:14 发布 621 阅读 AI 写同款· GEO 优化 ›
新手入门：从零开始学习PCB飞针测试全流程（附常见问题解答） 本文详细介绍了PCB飞针测试的全流程，从核心原理、设备解析到实操步骤和常见问题解答，帮助新手快速掌握这一电子制造领域的关键质检技术。内容涵盖测试资料准备、参数设置、设备操作技巧以及故障排查方法，特别适合小批量PCB生产的质量检测需求。 阅读详情

Java 内存模型JMM详解

JMM简介

Java Memory Model简称JMM, 是一系列的Java虚拟机平台对开发者提供的多线程环境下的内存可见性、是否可以重排序等问题的无关具体平台的统一的保证。(可能在术语上与Java运行时内存分布有歧义，后者指堆、方法区、线程栈等内存区域)。

并发编程有多种风格，除了CSP(通信顺序进程)、Actor等模型外，大家最熟悉的应该是基于线程和锁的共享内存模型了。在多线程编程中，需要注意三类并发问题:

1.原子性
2.可见性
3.重排序

原子性涉及到，一个线程执行一个复合操作的时候，其他线程是否能够看到中间的状态、或进行干扰。典型的就是i++的问题了，两个线程同时对共享的堆内存执行++操作，而++操作在JVM、运行时、CPU中的实现都可能是一个复合操作, 例如在JVM指令的角度来看是将i的值从堆内存读到操作数栈、加上一、再写回到堆内存的i，这几个操作的期间，如果没有正确的同步，其他线程也可以同时执行，可能导致数据丢失等问题。常见的原子性问题又叫竞太条件，是基于一个可能失效的结果进行判断，如读取-修改-写入。 可见性和重排序问题都源于系统的优化。

由于CPU的执行速度和内存的存取速度严重不匹配，为了优化性能，基于时间局部性、空间局部性等局部性原理，CPU在和内存间增加了多层高速缓存，当需要取数据时，CPU会先到高速缓存中查找对应的缓存是否存在，存在则直接返回，如果不存在则到内存中取出并保存在高速缓存中。现在多核处理器越基本已经成为标配，这时每个处理器都有自己的缓存，这就涉及到了缓存一致性的问题，CPU有不同强弱的一致性模型，最强的一致性安全性最高，也符合我们的顺序思考的模式，但是在性能上因为需要不同CPU之间的协调通信就会有很多开销。

典型的CPU缓存结构示意图如下
在这里插入图片描述
CPU的指令周期通常为取指令、解析指令读取数据、执行指令、数据写回寄存器或内存。串行执行指令时其中的读取存储数据部分占用时间较长，所以CPU普遍采取指令流水线的方式同时执行多个指令, 提高整体吞吐率，就像工厂流水线一样。

在这里插入图片描述
读取数据和写回数据到内存相比执行指令的速度不在一个数量级上，所以CPU使用寄存器、高速缓存作为缓存和缓冲，在从内存中读取数据时，会读取一个缓存行(cache line)的数据（类似磁盘读取读取一个block）。数据写回的模块在旧数据没有在缓存中的情况下会将存储请求放入一个store buffer中继续执行指令周期的下一个阶段，如果存在于缓存中则会更新缓存，缓存中的数据会根据一定策略flush到内存。

public class MemoryModel{    
    
    private int count;    
    
    private boolean stop;    
    
    public void initCountAndStop() {
        count = 1;
        stop = false;
    }    
    
    public void doLoop() {        
        
        while(!stop) {
            count++;
        }
    }    
    
     public void printResult() {
        System.out.println(count);
        System.out.println(stop);
    }
}

上面这段代码执行时我们可能认为count = 1会在stop = false前执行完成，这在上面的CPU执行图中显示的理想状态下是正确的，但是要考虑上寄存器、缓存缓冲的时候就不正确了, 例如stop本身在缓存中但是count不在，则可能stop更新后再count的write buffer写回之前刷新到了内存。

另外CPU、编译器（对于Java一般指JIT）都可能会修改指令执行顺序，例如上述代码中count = 1和stop = false两者并没有依赖关系，所以CPU、编译器都有可能修改这两者的顺序，而在单线程执行的程序看来结果是一样的，这也是CPU、编译器要保证的as-if-serial(不管如何修改执行顺序，单线程的执行结果不变)。由于很大部分程序执行都是单线程的，所以这样的优化是可以接受并且带来了较大的性能提升。但是在多线程的情况下，如果没有进行必要的同步操作则可能会出现令人意想不到的结果。例如在线程T1执行完initCountAndStop方法后，线程T2执行printResult，得到的可能是0, false, 可能是1, false, 也可能是0, true。如果线程T1先执行doLoop()，线程T2一秒后执行initCountAndStop, 则T1可能会跳出循环、也可能由于编译器的优化永远无法看到stop的修改。

由于上述这些多线程情况下的各种问题，多线程中的程序顺序已经不是底层机制中的执行顺序和结果，编程语言需要给开发者一种保证，这个保证简单来说就是一个线程的修改何时对其他线程可见，因此Java语言提出了JavaMemoryModel即Java内存模型，对于Java语言、JVM、编译器等实现者需要按照这个模型的约定来进行实现。Java提供了Volatile、synchronized、final等机制来帮助开发者保证多线程程序在所有处理器平台上的正确性。

在JDK1.5之前，Java的内存模型有着严重的问题，例如在旧的内存模型中，一个线程可能在构造器执行完成后看到一个final字段的默认值、volatile字段的写入可能会和非volatile字段的读写重排序。

所以在JDK1.5中，通过JSR133提出了新的内存模型，修复之前出现的问题。

重排序规则

volatile和监视器锁

是否可以重排序第二个操作第二个操作第二个操作
第一个操作普通读/普通写volatile读/monitor entervolatile读/monitor exit
普通读/普通写NO
voaltile读/monitor enteNONONO
volatile写/monitor exitNONO

其中普通读指getfield, getstatic, 非volatile数组的arrayload, 普通写指putfield, putstatic, 非volatile数组的arraystore。

volatile读写分别是volatile字段的getfield, getstatic和putfield, putstatic。

monitorenter是进入同步块或同步方法,monitorexist指退出同步块或同步方法。

上述表格中的No指先后两个操作不允许重排序，如(普通写, volatile写)指非volatile字段的写入不能和之后任意的volatile字段的写入重排序。当没有No时，说明重排序是允许的，但是JVM需要保证最小安全性-读取的值要么是默认值，要么是其他线程写入的（64位的double和long读写操作是个特例，当没有volatile修饰时，并不能保证读写是原子的，底层可能将其拆分为两个单独的操作）。

final字段

final字段有两个额外的特殊规则

1.final字段的写入（在构造器中进行）以及final字段对象本身的引用的写入都不能和后续的（构造器外的）持有该final字段的对象的写入重排序。例如, 下面的语句是不能重排序的

x = sharedRef; ...; i = x.finalField

2.final字段的第一次加载不能和持有这个final字段的对象的写入重排序，例如下面的语句是不允许重排序的

x = sharedRef; ...; i = x.finalField

内存屏障

处理器都支持一定的内存屏障(memory barrier)或栅栏(fence)来控制重排序和数据在不同的处理器间的可见性。例如，CPU将数据写回时，会将store请求放入write buffer中等待flush到内存，可以通过插入barrier的方式防止这个store请求与其他的请求重排序、保证数据的可见性。可以用一个生活中的例子类比屏障，例如坐地铁的斜坡式电梯时，大家按顺序进入电梯，但是会有一些人从左侧绕过去，这样出电梯时顺序就不相同了，如果有一个人携带了一个大的行李堵住了（屏障），则后面的人就不能绕过去了:)。另外这里的barrier和GC中用到的write barrier是不同的概念。

内存屏障的分类

几乎所有的处理器都支持一定粗粒度的barrier指令，通常叫做Fence(栅栏、围墙)，能够保证在fence之前发起的load和store指令都能严格的和fence之后的load和store保持有序。通常按照用途会分为下面四种barrier

LoadLoad Barriers

Load1; LoadLoad; Load2;

保证Load1的数据在Load2及之后的load前加载

StoreStore Barriers

Store1; StoreStore; Store2

保证Store1的数据先于Store2及之后的数据 在其他处理器可见

LoadStore Barriers

Load1; LoadStore; Store2

保证Load1的数据的加载在Store2和之后的数据flush前

StoreLoad Barriers

Store1; StoreLoad; Load2

保证Store1的数据在其他处理器前可见(如flush到内存)先于Load2和之后的load的数据的加载。StoreLoad Barrier能够防止load读取到旧数据而不是最近其他处理器写入的数据。

几乎近代的所有的多处理器都需要StoreLoad，StoreLoad的开销通常是最大的，并且StoreLoad具有其他三种屏障的效果，所以StoreLoad可以当做一个通用的(但是更高开销的)屏障。

所以，利用上述的内存屏障，可以实现上面表格中的重排序规则

需要的屏障第二个操作第二个操作第二个操作第二个操作
第一个操作普通读普通写volatile读/monitor entervolatile写/monitor exit
普通读LoadStore
普通读StoreStore
voaltile读/monitor enterLoadLoadLoadStoreLoadLoadLoadStore
volatile写/monitor exitStoreLoadStoreStore

为了支持final字段的规则，需要对final的写入增加barrier

x.finalField = v; StoreStore; sharedRef = x;

插入内存屏障

基于上面的规则，可以在volatile字段、synchronized关键字的处理上增加屏障来满足内存模型的规则

volatile store前插入StoreStore屏障
所有final字段写入后但在构造器返回前插入StoreStore
volatile store后插入StoreLoad屏障
在volatile load后插入LoadLoad和LoadStore屏障
monitor enter和volatile load规则一致，monitor exit 和volatile store规则一致。

HappenBefore

前面提到的各种内存屏障对应开发者来说还是比较复杂底层，因此JMM又可以使用一系列HappenBefore的偏序关系的规则方式来说明，要想保证执行操作B的线程看到操作A的结果（无论A和B是否在同一个线程中执行), 那么在A和B之间必须要满足HappenBefore关系，否则JVM可以对它们任意重排序。

HappendBefore规则包括

程序顺序规则: 如果程序中操作A在操作B之前，那么同一个线程中操作A将在操作B之前进行
监视器锁规则: 在监视器锁上的锁操作必须在同一个监视器锁上的加锁操作之前执行
volatile变量规则: volatile变量的写入操作必须在该变量的读操作之前执行
线程启动规则: 在线程上对Thread.start的调用必须在该线程中执行任何操作之前执行
线程结束规则: 线程中的任何操作都必须在其他线程检测到该线程已经结束之前执行
中断规则: 当一个线程在另一个线程上调用interrupt时，必须在被中断线程检测到interrupt之前执行
传递性: 如果操作A在操作B之前执行，并且操作B在操作C之前执行，那么操作A在操作C之前执行。

其中显示锁与监视器锁有相同的内存语义，原子变量与volatile有相同的内存语义。锁的获取和释放、volatile变量的读取和写入操作满足全序关系，所以可以使用volatile的写入在后续的volatile的读取之前进行。

可以利用上述HappenBefore的多个规则进行组合。

例如线程A进入监视器锁后，在释放监视器锁之前的操作根据程序顺序规则HappenBefore于监视器释放操作，而监视器释放操作HappenBefore于后续的线程B的对相同监视器锁的获取操作，获取操作HappenBefore与线程B中的操作。

原文链接 : https://mp.weixin.qq.com/s/K7eWTONtObhgsLvFpwj5CA

收录于
面试题

当前文章被收录于：

面试题
5 篇文章 0 人学习
订阅专栏 查看详情
标签
#JMM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
ThingsBoard - 设备接入 设备接入笔记 阅读详情

相关推荐

【编号326】全国地灾数据全国25万多个地质灾害点空间分布数据

全国地质灾害点分布数据涵盖25万多个各类灾害点信息，为灾害防治提供重要依据。通过分析灾害分布规律，可识别高风险区，指导监测预警、应急避险和基础设施建设。多地成功案例（如湖北兴山崩塌避险、重庆长寿滑坡预警、湖南"挪床行动"）证明，提前预警和科学防治能有效避免人员伤亡。云南省2024年通过预警体系成功避让31起灾害，保护1342人生命安全。这些实践表明，地质灾害防治需结合科技手段与群防体系，实现早预警、早处置。

千奇百怪无奇不有 1472

【JVM】JVM08(java内存模型解析[JMM])

java内存模型解析，建议收藏

wenwenaier的博客 2666

Python 静态导入与动态导入

python中模块的静态导入 与 动态导入(运行时指定模块)，以及具体对应示例。

慢也好，步子小也好，往前走就好~ 717

【Java八股文之进阶篇（二）】JMM内存模型

JMM内存模型、重排序、volatile关键字、happens-before原则

Kplusone的博客 2326

huggingface使用git上传model或者Dataset到HF,当然也可以上传代码，以及大文件，很哇塞！！！

huggingface使用git上传model或者Dataset到HF,当然也可以上传代码，以及大文件，很哇塞！！！ 第一次使用时，需要使用设置系统全局的huggingface token，这。点击huggingface首页右上角的头像 → settings → access tokens，创建一个write权限的token，名字可以随便取。

拥抱具身智能，昇腾Ascend C 3105

杰理SDK入门教程（五）：按键使用配置

摘要 杰理SDK提供IO按键和AD按键两种方案。IO按键通过GPIO电平检测实现，配置时需要设置板级宏定义和硬件连接，默认使用PB1引脚。AD按键基于ADC电压采样，通过电阻分压区分按键，需配置功能使能、硬件通道和键值适配。按键功能通过修改SDK中的key_table文件实现。两种方案适用于不同硬件场景，开发者可根据需求选择。

qq_42014563的博客 776

JVM（入门篇08）JMM Java内存模型模型. 详解.

一、什么是JMM？ 1.定义： JMM（Java Memory Model）Java内存模型. 2. JMM 和 JVM 的区别 JVM内存模型指的是 – 内存分区图 JMMJava内存模型 指的是 一种**==虚拟机规范==.** 二、JMM有何用？ 1. （抽象）定义了主内存和线程之间的关系： 之前在多线程安全问题的产生 的时候也涉及到了点击跳转 1.共享变量在主内存中 （Main Memory） 2.每个线程在本地内存（Local Memory) 3.本地内存和主内存是抽象的概念，物理上不存在，只

半亩方糖 939

【SAP ME 3】JAVA 调用SAP PO WebService

Java调用SAP PO/PI WebService接口

探索 Java 编程的技巧、最佳实践和解决方案。本博客提供针对 Java 开发者的实用指南，涵盖从基础到高级话题，旨在提升编程效率和技能。 847

Java8 对应的 JMM 划分

参考资料： 1、 JVM(二)Java8内存划分 https://blog.youkuaiyun.com/yjp198713/article/details/78759933 2、JAVA7、JAVA8的堆内存有啥变化 https://blog.youkuaiyun.com/chlu113/article/details/51890469 3、Java8—底层内存结构方法区 https://blog.csdn...

HeatDeath的博客 1447

数据结构之博弈树搜索(深度优先搜索)

数据结构之博弈树搜索(深度优先搜索)

LucianaiB的博客 1525

67、全球导航卫星系统授时弹性分析与建议

本文分析了全球导航卫星系统（GNSS）在授时过程中面临的问题，包括系统自身异常和外部干扰欺骗，并探讨了提升授时弹性的关键技术与解决方案。文章介绍了美国、欧洲及中国在弹性授时系统建设方面的进展，重点剖析了高精度原子钟、时间同步、干扰检测与识别等核心技术，提出了GNSS与其他授时系统互补的集成化发展路径。最后展望了未来授时系统向更高精度、更强弹性、更广应用的发展趋势，为构建安全可靠的国家授时体系提供参考。

corn8的博客 185

总结：对Java内存模型JMM的理解

JMM规定了线程的工作内存和主内存的交互关系，以及线程之间的可见性和程序的执行顺序。一方面，要为程序员提供足够强的内存可见性保证；另一方面，对编译器和处理器的限制要尽可能地放松。JMM对程序员屏蔽了CPU以及OS内存的使用问题，能够使程序在不同的CPU和OS内存上都能够达到预期的效果。 在jsr-133中是这么定义的 A memory model describes, given a

RipL的专栏 4266

第1讲｜AI产品经理全景图谱：不是“会用AI工具”，而是能对AI产品结果负责

本文从岗位本质出发，系统拆解 AI 产品经理的职责、岗位类型与能力模型，帮助读者理解 AI PM 与传统 PM 的核心差异，明确自己适合的转型方向，并建立“对 AI 产品结果负责”的产品认知。

从零开始，掌握网络安全。提供全面的网络安全教程、攻防演练技巧和行业动态。 1016

JMM（Java内存模型）详解

1.什么是JMM？ ​ JMM 是Java内存模型（ Java Memory Model），简称JMM。它本身只是一个抽象的概念，并不真实存在，它描述的是一种规则或规范。通过这组规范，定义了程序中对各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。 ​ 计算机在执行程序时，每条指令都是在CPU中执行的。而执行指令的过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过

LYQ20010417的博客 3万+

WINCC7.3破解文件

WINCC7.3硬件够破解文件，有需要的下载！WINCC7.3硬件够破解文件，有需要的下载！

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Java内存模型—JMM详解

JMM

可达鸭的博客 3643

温度PID控制PLC程序

温度PID稳定控制程序，适用于欧姆龙PLC，对其他PLC也具有很大参考价值

Java 内存模型（JMM）详解

在Java的多线程编程中，如何确保线程间共享变量的可见性和同步是一个关键问题。Java内存模型（Java Memory Model, JMM）正是为解决这些问题而设计的。本文将简要介绍JMM的基本概念、工作原理及其在多线程编程中的作用。

✨ 欢迎来到【Seal ^_^ 的优快云博客】！✨ 6668

JMM(Java内存模型)详解

为了对上面的问题进行更深入的探究，我有查了一些JIT相关的资料。简单总结下JIT然后再对上面的问题分析下。JIT（Just-In-Time）编译器是Java虚拟机（JVM）中的一个关键组件，它负责在程序运行过程中动态地将字节码（即Java编译后的.class文件中的代码）转换为特定于平台的机器代码。这一过程旨在提高程序的执行效率，因为它能够针对运行时的数据和实际使用模式进行优化，而不仅仅是基于静态代码分析。JIT工作原理加载与解释执行：当Java程序启动时，JVM首先加载类文件并由解释器执行字节码。

落日的博客 4170

JMM详解(Java内存模型)

一开始就需要情调一下，JMM与JVM是两个概念，JVM指的是JVM虚拟机，但是JMM指的是Java内存模型！！！！！！当然JVM内存模型与JMM内存模型也不是一个东西！！！！以下是我个人对JMM的理解，希望和大家一起探讨！

多敲代码防脱发的博客 826

Java内存模型(JMM)详解

为什么要有内存模型 在现代多核处理器中，每个处理器都有自己的缓存，定期的与主内存进行协调。 想要确保每个处理器在任意时刻知道其他处理器正在进行的工作，将需要很大的开销，且通常是没必要的。 硬件的效率与一致性 由于计算机的存储设备与处理器的运算能力之间有几个数量级的差距，所以现代计算机系统都不得不加入一层读写速度尽可能接近处理器运算速度的高速缓存（cache）来作为内存与处理器之间的缓冲：将运算...

牧小农 4510

java内存模型(JMM)详解

转载于： 面试官：说说什么是Java内存模型？为什么要有内存模型？ 要想回答这个问题，我们需要先弄懂传统计算机硬件内存架构。好了，要开始画图了 硬件内存架构图 含有一二三级架构的内存架构图 去过机房的同学都知道，一般在大型服务器上会配置多个CPU，每个CPU还会有多个核，这就意味着多个CPU或者多个核可以同时（并发）工作。如果使用 起了一个多线程的任务，很有可能每个 都会跑一个线程，那么你的任务在某一刻就是真正并发执行了。也就是 。是 内部集成的，在寄存器上执行操作的效率要比在主存上高出几个数量级在中

thlzjfefe的博客 1356

java内存模型 JMM详解

什么是JMM模型 JMM是一种抽象的概念，并不真实存在，是一组规范或者规则；关注的是多个线程对共享内存空间和线程私有工作空间的访问方式，围栏并发的原子性、有序性、可见性来展开的，想要了解JAVA的并发编程，就应该理解JMM。 JMM通过定义了对变量（包括实例成员、静态成员和组成数组对象的元素）的访问方式，在程序运行时，运行程序的是实体是线程，每个线程创建时候，虚拟机都会为每个线程分配一定的内存空间，每个线程的内存空间用来存储线程私有的数据。但是JMM中规定数据都是存储在共享的主内存空间，而且每个线.

Angus 1380

Java内存模型(JMM)详解！

JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JMM可以理解为是一个规范，一个抽象概念，并不真实存在。

追寻心的步伐 1716

JMM（Java 内存模型）详解

Java 是最早尝试提供内存模型的编程语言。由于早期内存模型存在一些缺陷（比如非常容易削弱编译器的优化能力），从 Java5 开始，Java 开始使用新的内存模型。一般来说，编程语言也可以直接复用操作系统层面的内存模型。不过，不同的操作系统内存模型不同。如果直接复用操作系统层面的内存模型，就可能会导致同样一套代码换了一个操作系统就无法执行了。Java 语言是跨平台的，它需要自己提供一套内存模型以屏蔽系统差异。这只是 JMM 存在的其中一个原因。

m0_53157173的博客 886

详解JMM——java内存模型

摘要： CPU缓存通过三级结构（一二级私有、三级共享）解决CPU与内存速度不匹配问题，内存则缓解磁盘访问慢的问题。Java内存模型（JMM）抽象了线程与主内存的关系，定义主内存（存储共享数据）和本地内存（线程私有副本），通过8种操作（如read/write、lock/unlock）实现交互。JMM还提出happens-before原则确保指令顺序性和可见性，包括程序顺序、volatile变量、线程启动等规则，允许重排序但需保持结果一致性，以支持跨平台并发安全。

jrbbad的博客 1479

Java内存模型（JMM）详解

摘要：JMM(Java内存模型)是规范多线程环境下共享变量访问规则的一套抽象规范，主要解决可见性、原子性和有序性问题。JMM通过synchronized保证原子性和有序性，强制主内存与工作内存同步；通过volatile保证可见性，防止指令重排序；配合Happens-Before原则确保操作顺序。这些机制使开发者无需了解底层硬件细节，就能编写线程安全的代码。JMM不同于JVM内存结构，是专门针对多线程并发问题的解决方案。

rchm8519的专栏 1998

【Java锁体系】七、JMM内存模型详解

【Java锁体系】七、JMM内存模型详解 JMM是Java的内存模型，与Java的内存区域(运行时数据集区域)是不同的，是两个完全的概念。 Java内存模型JMM：解决多线程下，线程间通信的类似的问题； JVM运行数据区：对象内存自动化管理。 7.1 为什么要存在JMM这抽象概念? 由于JVM运行程序的实体是线程，而每个线程创建时都会为其创建一个工作内存（有些地方称之为栈空间）用于存储线程私有的数据，线程与主内存中的变量操作必须通过工作内存间接完成，主要过程是讲变量从主内存拷贝到每个线程各自的工作内存空间，

Mind_programmonkey的博客 619

JAVA内存模型(JMM)详解

引言 为了更好的了解底层原理，写出更加高效的代码，今天我们 详细的分析一下JAVA内存模型(JMM),JAVA内存模型是我们深入了解java并发变成的先决条件。对于后续多线程 中的线程安全，同步异步处理等更是大有裨益。 硬件内存架构 在学习java内存模型之前，先了解一下计算机硬件模型，我们都知道处理器与计算机存储设备运算速度有几个数量级的差别。总不能让处理器一直等待计算机存储设备，这样就没...

Jack 架构师之路 1081
上一篇： 【面试题】-【JVM】
下一篇： 彻底搞懂HashMap,HashTable,ConcurrentHashMap之关联
点赞 1
评论 2
书签 书签 3
春来桃花开
春来桃花开
博客等级 码龄10年 21粉丝 30原创
+ 关注 专栏目录 订阅专栏
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值