解析Java 内存模型—— JMM

【JVM】JVM08(java内存模型解析[JMM])_java 8 jvm内存模式 在这个部分总结了2019年到目前为止Java常见面试问题,取其面试核心编写成这份文档笔记,从中分析面试官的心理,摸清面试官的“套路”,可以说搞定90%以上的Java中高级面试没一点难度。本节总结的内容涵盖了:消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。(上述只是一个整体目录大纲,每个点里面都有如下所示的详细内容,从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程) 阅读详情

本文主要介绍JMM原理。Java Memory Model简称JMM, 是一系列的Java虚拟机平台对开发者提供的多线程环境下的内存可见性、是否可以重排序等问题的无关具体平台的统一的保证。

JMM简介

Java Memory Model简称JMM, 是一系列的Java虚拟机平台对开发者提供的多线程环境下的内存可见性、是否可以重排序等问题的无关具体平台的统一的保证。(可能在术语上与Java运行时内存分布有歧义,后者指堆、方法区、线程栈等内存区域)。
并发编程有多种风格,除了CSP(通信顺序进程)、Actor等模型外,大家最熟悉的应该是基于线程和锁的共享内存模型了。在多线程编程中,需要注意三类并发问题:

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

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

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

典型的CPU缓存结构示意图如下

Java 内存模型 JMM 浅析

CPU的指令周期通常为取指令、解析指令读取数据、执行指令、数据写回寄存器或内存。串行执行指令时其中的读取存储数据部分占用时间较长,所以CPU普遍采取指令流水线的方式同时执行多个指令, 提高整体吞吐率,就像工厂流水线一样。

Java 内存模型 JMM 浅析

读取数据和写回数据到内存相比执行指令的速度不在一个数量级上,所以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 enterNoNoNo
volatile写/monitor exit NoNo

其中普通读指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.finalField = v; ...; sharedRef = x;
  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 exit  StoreLoadStoreStore

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

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

插入内存屏障

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

  1. volatile store前插入StoreStore屏障
  2. 所有final字段写入后但在构造器返回前插入StoreStore
  3. volatile store后插入StoreLoad屏障
  4. 在volatile load后插入LoadLoad和LoadStore屏障
  5. monitor enter和volatile load规则一致,monitor exit 和volatile store规则一致。
HappenBefore

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

HappenBefore规则列表

HappendBefore规则包括

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

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

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

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

参考

高精度计算Π的值(C语言) 题目要求 限制使用双向链表作存储结构,请根据用户输入的一个整数(该整数表示精确到小数点后的位数,可能要求精确到小数点后500位),高精度计算PI值。可以利用反三角函数幂级展开式来进行计算。 输入5 输出3.14159 思路分析 反三角函数幂级展开式 由公式可以看出,只要计算出来每一个R(n)的值再相加取二倍就可以得到Π的值。 经过推算,要是令R(1)=2,只需要将每个R(n),相加即可。 因... 阅读详情

相关推荐

XVF3800麦克风阵列实战:从选型到快速原型搭建

本文详细介绍了XVF3800麦克风阵列的选型与快速原型搭建实战经验。从开箱即用的特性到波束成形、回声消除等核心功能拆解,再到硬件设计避坑指南和固件开发技巧,帮助开发者高效实现智能语音设备的开发。特别适合智能音箱、会议终端等需要远场拾音和声源定位的应用场景。

weixin_29161719的博客 275

面试官问我什么是JMM

什么是JMM,什么是内存屏障,看这篇就够了

yehongzhi1994的博客 2732

Rapid SCADA MQTT

一、配置RapidSCADA 1、准备KpMqtt.dll、Jint.dll库文件,从网盘下载。 2、将以上两个文件拷贝到SCADA安装目录的Comm/KP目录下,如下: C:\SCADA\ScadaComm\KP 3、新建SCADA项目 4、新建Line 5、新建Device 6、拷贝Config目录下的KpMqtt_001.xml文件、KpMqtt_Job.js文件到项目Comm\Config下,如下示例链接 C:\SCADA\Projects\MQTTProject\Instances\Defau

mumanquan1的博客 3008

Java二进制指令代码解析

Java二进制指令代码解析 小注:去年在看《深入解析JVM》书的时候做的一些记录,同时参考了《Java虚拟机规范》。只是对指令的一些列举,加入了一些自己的理解。可以用来查询。 Java二进制指令代码解析 Java源码在运行之前都要编译成为字节码格式(如.class文件),然后由ClassLoader将字节码载入运行。在字节码文件中,指令代码只是其中的一部分,里面还记...

我的java 博客,嘿嘿 421

Java 开发打飞机小游戏(附完整源码)

上图 写在前面 技术源于分享,所以今天抽空把自己之前用java做过的小游戏整理贴出来给大家参考学习。java确实不适合写桌面应用,这里只是通过这个游戏让大家理解oop面向对象编程的过程,纯属娱乐。代码写的很简单,也很容易理解,并且注释写的很清楚了,还有问题,自己私下去补课学习。 完整代码 敌飞机 import java.util.Random; 敌飞机: 是飞行物,也是敌人 public class Airplane extends FlyingObject implements Enemy {

一只独孤的程序猿 1万+

Vivado与VCS+Verdi联合仿真环境搭建全攻略

本文详细介绍了如何搭建Vivado与VCS+Verdi联合仿真环境,旨在解决Vivado Simulator在大型FPGA验证中速度慢、调试弱的问题。通过指导工具版本配对、环境变量设置、关键参数配置及Xilinx仿真库编译,帮助工程师高效整合Vivado的设计管理、VCS的高速仿真与Verdi的深度调试能力,从而显著提升验证效率。

weixin_29219189的博客 581

JVM的Heap Memory和Native Memory

JVM管理的内存可以总体划分为两部分:Heap Memory和Native Memory。前者我们比较熟悉,是供Java应用程序使用的;后者也称为C-Heap,是供JVM自身进程使用的。Heap Memory及其内部各组成的大小可以通过JVM的一系列命令行参数来控制,在此不赘述。Native Memory没有相应的参数来控制大小,其大小依赖于操作系统进程的最大值(对于32位系统就是3~4G,各种系统

Venus专栏 1万+

手把手教你用CH340给正点原子ESP8266烧录固件(附串口调试技巧)

本文详细讲解了使用CH340模块为正点原子ESP8266烧录AT固件的完整流程与关键技巧。核心在于烧录时必须使用3.3V供电,并正确连接GPIO0引脚至GND以进入下载模式。文章涵盖了从硬件接线、软件参数配置到烧录后串口调试验证的全步骤,并提供了常见问题排查方案,帮助开发者一次性成功完成固件烧录。

weixin_29201933的博客 235

Java内存模型(JMM)详解,linux入门基础教程在线

在现代多核处理器中,每个处理器都有自己的缓存,需要定期的与主内存进行协调。 想要确保每个处理器在任意时刻知道其他处理器正在进行的工作,将需要很大的开销,且通常是没必要的。 1.1 硬件的效率与一致性 1、 由于计算机的存储设备与处理器的运算能力之间有几个数量级的差距,所以现代计算机系统都不得不加入一层读写速度尽可能接近处理器运算速度的高速缓存(cache)来作为内存与处理器之间的缓冲:将运算需要使用到的数据复制到缓存中,让运算能快速进行,当运算结束后再从缓存同步回内存之中没这样处理器就无需等待缓..

m0_64867092的博客 707

Windows10下安装VMware16虚拟机

由于本人系统为Windows 10 家庭中文版,无法安装Linux子系统WSL,虽然网上也有强制安装的方法,但为保险起见,还是把之前的VMware虚拟机重新进行安装,并浅浅记录一下安装过程。

沉香best的博客 866

自动驾驶模拟器:基于 Python + Carla,在家也能训练一个“L4 级”自动驾驶 AI 模型

市面上有很多模拟器(AirSim, LGSVL),但 Carla 是目前学术界和工业界最主流的选择。画质强:基于 UE4,光影、天气(下雨、夕阳)极其逼真,这对训练视觉模型至关重要。API 爽:完全使用 Python 控制,对 AI 工程师极度友好。资产多:内置各种车辆、行人、交通信号灯、城市地图。编写 Python 代码,让车自己在城市里跑,通过摄像头看到路况,自己决定怎么打方向盘。通过 Carla,我们把价值数百万的自动驾驶测试场搬进了电脑。

BUG猿的博客 270

并发编程之JMM内存模型(一)— 底层实现原理

一丶前言 什么是JMM? JMM(Java Memory Model)即Java内存模型,Java语言规范中提到过,JVM中存在一个主存区(Main Memory或Java Heap Memory),Java中所有变量都是存在主存中的,对于所有线程进行共享,而每个线程又存在自己的工作内存(Working Memory),工作内存中保存的是主存中某些变量的拷贝,线程对所有变量的操作并非发生在主...

liu8521300的博客 521

【数据集】全球预报系统GFS概述:数据下载及处理

【数据集】全球预报系统GFS概述:数据下载及处理

WW、forever的博客 5752

Java内存模型(JMM)深度解析

Java内存模型(JMM)是Java并发编程的核心规范,定义了多线程环境下变量访问规则和线程交互机制。JMM采用主内存与线程工作内存的抽象模型,通过8种原子操作控制内存交互,并建立happens-before原则保证操作顺序性。文章详细解析了内存屏障的实现差异、final字段的特殊规则、双重检查锁定的解决方案,以及JMM与硬件内存模型的关系。同时提供了可见性问题、指令重排序等常见并发问题的分析,并给出安全发布模式和性能优化建议。理解JMM是编写正确高效并发程序的关键,它既保证了线程安全,又为JVM优化提供了

weixin_47242663的博客 1272

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Java内存模型(JMM)深度解析

Java内存模型(JMM)是Java并发编程的基石,它定义了线程如何通过内存进行交互,以及对共享变量的修改何时对其他线程可见。我们了解到,可见性问题源于CPU缓存导致的数据不一致,可以通过volatile关键字解决;有序性问题源于编译器和处理器的指令重排序,JMM通过原则和volatile关键字来保证;原子性则通过关键字来确保操作的不可中断性。原则作为JMM的基石,为我们理解和分析并发程序的行为提供了强有力的理论依据。正确使用JMM提供的同步机制是避免并发问题的关键。

weixin_56018532的博客 774

深度学习工具包 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解析

java 内存模型JMM解析一、CPU多核并发缓存架构解析   1、以往的内存读取   2、后来的内存读取二、java内存模型实现原理三、深入理解volatile关键字四、并发编程的可见性、原子性和有序性 一、CPU多核并发缓存架构解析    1、以往的内存读取 读取读取主内存数据存储于硬盘CPU      存在的问题就是,主内存的运行速度严重限制了CPU的效率    2、后来的内存读取 读取读取...

Chengqb的博客 692

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Java之JMM内存模型解析

图文来自公众号: Cai小白 更多教程请访问: www.xiaodoulearn.com 一、线程与JVM 1.1 基本概念 程序:是指一组指示电子计算机或其他具有消息处理能力设备每一步动作的指令,通常用某种程序设计语言编写,运行于某种目标体系结构上(静态概念) 进程:是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础(动态概念) 线程:是操作系统能夠進行運算调度的最小單位。大部分情况下,它被包含在进程之中,是进程中的實際運作單位。..

n8z6hr的博客 205

【并发编程】Java 内存模型(JMM)深度解析

Java 内存模型(,简称JMM)是 Java 并发编程的基石之一,是一种抽象规范并不是物理意义上的东西。。在 JDK1.2 之前,Java 的内存模型实现总是从 主存 (即共享内存)读取变量,是不需要进行特别的注意的。而在当前的 Java 内存模型下,线程可以把变量保存 本地内存 (比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值的拷贝,造成数据的不一致。

枫叶 1238

Java 内存模型(JMM)全解析

Java 内存模型(JMM)是解决多线程并发中内存一致性问题的抽象规范,通过定义主内存与工作内存的交互规则,确保可见性、原子性和有序性。JMM不同于JVM运行时数据区,它关注线程间共享变量的访问规则而非物理内存结构。核心概念包括主内存(存储共享变量)和工作内存(线程私有副本),通过8种原子操作规范变量交互。JMM解决三大问题:可见性(通过volatile、synchronized强制刷新内存)、原子性(使用synchronized或原子类保证操作完整性)、有序性(禁止指令重排序)。典型应用包括volatil

weixin_45251121的博客 878

深入解析JMM:Java内存模型与并发编程

主内存(Main Memory)定义:在JMM中,主内存是所有线程共享的内存区域存储内容:存储所有的共享变量(实例字段、静态字段等),约等于JVM堆中真正被多线程共享的部分 + 方法区的静态变量,或者是计算机中的内存(注意内存和外存的区别)特点:1.线程对共享变量的所有操作(读/写)都必须在主内存中进行2.是线程间通信的媒介3.对应于物理内存,但不等同于JVM堆内存工作内存(Working Memory)定义:每个线程私有的内存区域存储内容:存储该线程使用到的变量的主内存副本,约等于。

FQY__的博客 940

​Java内存模型(JMM)核心解析

Java内存模型(JMM)定义了多线程环境下,线程如何与内存交互的规则,​解决可见性、有序性和原子性问题,是理解并发编程的基础。

sunofbeach_123的博客 1546

JAVA内存模型解析(JMM)

Java内存模型JAVAMemory Model,个人理解就是一组规则,这组规则意在解决在并发编程可能出现的线程安全问题,并提供了内置解决方案(happen-before原则)及其外部可使用的同步手段(synchronized/volatile等),确保了程序执行在多线程环境中的应有的原子性、可见性、有序性。JAVA内存区域堆方法区:线程共有栈本地方法栈 程序计数器:线程私有 堆存储对象和数组(数...

仲文的博客 669

并发编程之 JMM(Java 内存模型)深度解析

在并发编程领域,Java 内存模型(JMM)是至关重要的概念,它为我们理解多线程环境下的数据一致性和内存可见性问题提供了理论基础。

m0_57836225的博客 516

JVM 完整深入解析(包括JMM Java内存模型)

JVM 完整深入解析

Jaemon 782

清晰万字解析:Java内存模型(JMM)

//Java内存模型JMM用来描述多线程环境中共享变量的内存可见性。//JMM和 Java 运行时内存区域的划分,这两者既有差别又有联系。//JMM内存可见性问题(为什么出现?在哪里出现?怎么解决?)。//JMM 与重排序(保证运行高效)。//JMM与顺序一致性模型(保证答案正确)。

JIGUANGDI 1426

Java全栈面试宝典:JMM内存模型与Spring自动装配深度解析

💬 你在项目中如何平衡自动装配与显式配置?遇到过哪些有趣的依赖问题?:对于long/double等64位操作能保证单次读写的原子性。:需要配合synchronized或Atomic类。:如i++这类"读-改-写"操作不能保证原子性。🎁 关注+转发,查询更新《Spring揭秘》时优先选择构造器注入。

2403_89107873的博客 1292
上一篇: 90后分享学习linux系统全过程
下一篇: 利用树莓派和 Arduino开发机器人
linuxprobe2017
博客等级 码龄10年 123粉丝 294原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值