OOM内存溢出实战不得不看的经典

jvm性能调优实战 - 43OOM内存溢出发生的原因及可能发生OOM的内存区域 文章目录OOMOOM是如何产生的JVM进程怎么执行你写的那些代码Java虚拟机栈:让线程执行各种方法堆内存:放我们创建的各种对象小结 OOM 先不考虑自己系统外部依赖的缓存、消息队列、数据库等等东西挂掉,就我们自己系统本身而言,最常见的挂掉的原因是什么? 其实就是系统OOM,也就是所谓的内存溢出! 其实说白了,也非常非常的简单,一句话形容,你的JVM内存就这么点,结果你拼命的往里面塞东西,结果内存塞不下了,不就直接溢出了吗? 看看下面的这个图 至于到底JVM是如何放不下对象导致内存溢出的,这个大家不要着 阅读详情

各种OOM的溢出实战及对象、布局、访问、对存活判断及引用

 

一、虚拟机中的对象

我们JAVA编程中无时无刻都在操作创建对象,那么我们虚拟机在遇到new关键词创建对象的执行过程是怎样的?

1、例如我们有一个User类首先检查是否存在这个User类,然后看是否有没有被加载过,如果没有加载JVM会先进行User加载。

2、加载完成后我们会在堆中分配特定大小的内存进行分配。

   (1)、划分内存的方法:指针碰撞:例如一块方格的堆内存区域,假如前面两个已经被分配了,要分第三个内存块给User这个类,那么只要指针移动一个位置即可,这种方式即为指针碰撞的划分内存方法。

   (2)空闲列表:例如一块方格的堆内存区域,假如已经分配的内存不规整,犬牙交错的已经分配了内存,那这个时候要分内存块给User这个类,显然用指针碰撞的方式已经不适用,这个时候我们就可以弄一个列表来维护可分配的内存块,哪些用过的打勾,哪些用过的打叉这种方式就叫空闲列表的划分内存方法。  

 采用哪种划分内存的方法,由我们堆的内存是不是规整来决定,堆的内存是否规整由我们的垃圾回收器是否有这种压缩整理来决定。

除了划分内存方法不同的问题,还有并发安全的问题

   (1)、拿指针碰撞的方式来讲,如果一个线程A对象要分配一个内存,假如指针还没移动,线程B对象也要分配内存,这时候会产生,A对象和B对象都会使用这个区域。怎么解决这个问题  

   (2)、用CAS配上失败重试:CAS(比较并替换) 并发编程中讲的很详细,CAS机制中使用了3个基本操作数:内存地址V,旧的预期值A,要修改的新值B。更新一个变量的时候,只有当变量的预期值A和内存地址V当中的实际值相同时,才会将内存地址V对应的值修改为B。    

 3、内存分配完成后,进行内存空间初始化,赋初值指的是同一给integer赋值0,String赋值空白字符串。

 4、接下来就是设置:设置是指表明这个对象是哪个类的实例,通过这个对象我们怎么拿到这个类的相关的元数据信息,还有常说的对象哈希码,对象的GC分代年龄,这些信息是放在对象的头里面的。

 5、到了对象初始化,我们才这正来执行我们所写的Employee的构造方法这些动作。

二、对象的布局

总体的布局可以分为三个区

       1、对象头:包含两个部分

        (1)、对象自身的运行时数据:常用的哈希码、锁的状态、并发编程里面的偏向锁、时间戳等等。

        (2)、类型指针:指向的是这个类的元数据,JVM通过这个类型指针来找个这个对象是哪个类的实例。

       2、实例数据:程序代码中所定义的各种类型的字段内容,就是我们Use中定义的id和name的值。

       3、对齐填充:就是由JVM来做的,就是一个占位,HotSpot要求对象的起始地址必须是八个字节的整数倍也就是对象的大小一定是八个字节的整数倍,所以说如果对象头加实例数据不是八个字节的整数倍时就需要对齐填充。
 

三、对象的访问

访问对象有两种方式:

    1、句柄:

  什么叫使用句柄?可以理解为一个门牌号码(指示牌),例子在内存中划分一块区域来作为一个句柄池,由句柄池来持有这个对象在哪个位置。例如:如果java栈要访问对象时,先由对象的引用先指向句柄池,不直接指向对象,再由句柄池来拿到对象的实例数据和对象的类型数据。

 2、直接指针

     就是java栈要拿某个对象的实例数据时,就直接指向了这个对象的实例数据地址,不需要通过句柄池来转一遍。   

两种访问方式再虚拟机中都存在使用句柄的好处,因为指向的是句柄池,不是一个固定的值,如果当对象发生移动的时候 移动是非常普遍的,因为会有垃圾收集。移动后我只需要改变句柄池的指向地址即可。使用直接指针的好处明显是少了句柄的转发,访问对象速度明显提升。Hotspot虚拟机中用的是直接指针的访问方式。  
 

四、实战演练各种OOM溢出

1、堆溢出(代码示例)

import java.util.LinkedList;
import java.util.List;
 
/**
 * @ClassName MyOOMTest$
 * @Description TODO
 * QQ号:48793696
 * @date 2019/5/14 16:58
 * @Version 1.0
 **/
public class MyOOMTest {
    /***
     *
     * VM参数:-Xms5m -Xmx5m -XX:+PrintGC
     */
    public static void main(String[] args){
        //String[] strings = new String[100000000];
       List<Object> list = new LinkedList<Object>();
        int temp = 0;
        while(true){
            temp++;
            if(temp%10000 == 0)System.out.println("temp = "+temp);
            list.add(temp);
        }
    }
}

执行结果抛出了OutOfMemory:java.lang.OutOfMemoryError: GC overhead limit exceeded,JVM发现内存不足的时候GC进行回收,但是回收的条件非常苛刻,导致没有回收的速度没有跟上新建对象的速度,导致了堆溢出。


import java.util.LinkedList;
import java.util.List;
 
/**
 * @ClassName MyOOMTest$
 * @Description TODO
 * @Author QQ号:48793696
 * @date 2019/5/14 16:58
 * @Version 1.0
 **/
public class MyOOMTest {
    /***
     *
     * VM参数:-Xms5m -Xmx5m -XX:+PrintGC
     */
    public static void main(String[] args){
        String[] strings = new String[100000000];
      
    }
}

执行结果也会抛出异常,但是我们看到的现象是GC的次数明显减少、抛出的是java.lang.OutOfMemoryError: Java heap space。

前面的代码因为一直在new Object(),一直累积,到最后只有一点点空间不够进行分配,然后GC试着进行回收,一直不停尝试,直到达到超过回收的最大次数,GC也发现臣妾做不到,认命之后抛出GC overhead limit exceeded。

String[] strings = new String[100000000];这个相当于分配一个巨型数组,类似于超过5M的东西硬要塞到5M的内存中去,这时候GC还是意思下的去回收下,然后发现还是塞不下,就干净利落的抛出java.lang.OutOfMemoryError: Java heap space

我们可以根据这两个异常来确定我们写代码的时候出现什么问题?

如果出现GC overhead limit exceeded,很有可能你在代码中出现了某种循环里面在不停的分配对象,虽然不大,但是分配的太多,把堆撑爆了。如果出现java.lang.OutOfMemoryError: Java heap space,在分配的时候,有巨型对象在分配,以致于超出了堆的大小。

1、方法区溢出
 代码示例
 

import java.util.LinkedList;
import java.util.List;
 
/**
 * @ClassName MyMetaSpaceTest$
 * @Description TODO
 * @Author  QQ号:48793696
 * @date 2019/5/14 17:46
 * @Version 1.0
 **/
public class MyMetaSpaceTest {
    /***
     *
     * VM参数:-XX:MaxMetaspaceSize=3M
     */
    public static void main(String[] args){
        List<Object> list = new LinkedList<Object>();
        int temp = 0;
        while(true){
            temp++;
            if(temp%10000 == 0)System.out.println("temp = "+temp);
            list.add(temp);
        }
 
    }
}

执行的结果为:

这是因为我们在分配方法区的内存太小了,甚至不能保证我们JVM本身的运行。

  1. 虚拟机栈溢出

代码示例:

public class MyStackOOMTest {
    /***
     * VM参数:-Xss256k
     */
    private int stactSize = 1;
 
    //private  void recursive(int a ,String b){
     private  void recursive(){
        stactSize++;
        //recursive(a,b);
        recursive();
    }
    public static void main(String[] args){
        MyStackOOMTest myStackOOMTest = new MyStackOOMTest();
        try {
            //myStackOOMTest.recursive(10,"Allen");
            myStackOOMTest.recursive();
        }catch (Throwable e){
            System.out.println("stactSize ========"+myStackOOMTest.stactSize);
            e.printStackTrace();
        }
 
    }
}

执行结果为:

如果把递归的方法加上两个参数(int a,String b)执行的结果为

这样的结果比之前栈深度小了,栈大小我们也没有改变,我们只增加了递归方法的参数,意味着什么? 这代表我们的栈帧变大了,栈帧在之前讲过包含局部变量、操作数栈、帧数据区,局部变量包含这个方法的入参。这也就是说栈大小不变的情况下,如果参数越多,栈越浅,因为栈帧越大。

如果出现java.lang.StackOverflowError这种异常,要检查代码中是否有无限递归存在。很多出去面试会被问到二叉树的算法,问了递归还要问非递归,绝对是有原因的。有同学知道为什么吗?递归:如果用递归来实现,每次方法都会被打包成一个栈帧来执行,而每个方法打包成一个栈帧的过程要做的事情比较多,时间比较久,尤其是当方法的参数更多的时候耗费的时间就更长。非递归:非递归一般都是采用循环来实现树的遍历,循环来实现就取消了每次都要来打包成栈帧,出栈入栈的过程,所以说非递归算法或在树的遍历上天生就要比递归的方式速度要快。当树很浅的时候当然可以用递归,主要就是要控制递归的使用。

1、直接内存溢出
代码示例
 

import java.nio.ByteBuffer;
 
/**
 * @ClassName MyDirectMemoryTest$
 * @Description TODO
 * @Author  QQ号:48793696
 * @date 2019/5/15 13:53
 * @Version 1.0
 **/
public class MyDirectMemoryTest {
    /***
     *VM参数:-Xmx10M -XX:MaxDirectMemorySize=10M
     * */
    public static void main(String[] args){
        ByteBuffer.allocateDirect(1024 * 1024 * 14);
    }
}

执行结果:

java.lang.OutOfMemoryError: Direct buffer memory如果大家在代码中看到这类异常,通常发生在我们的NIO通讯中,在我们使用了NIO,不管你用的是dubbo还是netty框架,假如抛出了这类异常,如果检查发现运行时设置的内存又发现很小,我们就要考虑是不是发生了本机内存溢出了。

怎么判断对象的存活?
1、引用计数算法

  举个例子: 对象A(引用)——》对象B,对象C(引用)——》对象B ,会有一张表记录对象B被引用了两次1+1,对象A和对象B被引用0次。

  优点:快、方便、实现简单,引用计数很方便,GC来决定哪个对象需要回收时,只要来判断这个计数是不是为0,表示没有引用的对象就可以为回收。

 缺点:对象A(引用)——》对象B,对象B(引用)——》对象A,在表中记录对象A、 对象B都引用1次,这两个对象互相引用对方,导致他们的计数都不为0,于是导致GC永远不会回收。

适用场景:因为引用计数这个致命的问题导致Hotspot没有采用引用计数算法,但是早期的微软公司的COM技术、使用ActionScript 3的FlashPlayer、Python、都使用了引用计数算法来进行内存管理。

 2、可达性分析

jvm中用的就是可达性分析。

算法基本思想:

    通过一系列的称为"GC Roots"的对象作为起始点,从这些节点开始向下搜索。搜索所走过的路径称为引用链,当一个对象到GC Roots没有任何引用链相连(也就是说从GC Roots)到这个对象不可达)时,则证明此对象是不可用的。如图所示,对象Object5、Object6、Object7虽然互相有关联,但它们到GC Roots是不可达的,所以他们将会被判定为是可回收的对象。

GC Roots对象:

      在Java语言中,可作为GC Roots的对象包括下面几种:

虚拟机栈(栈帧中的本地变量表)中引用的对象。

方法区中类静态属性引用的对象   例如:static User u = new User();

方法区中常量引用的对象

本地方法栈中JNI(即一般说的Native方法)引用的对象

所谓“GC roots”,或者说tracing GC的“根集合”,就是一组必须活跃的引用。 例如说,这些引用可能包括:所有Java线程当前活跃的栈帧里指向GC堆里的对象的引用;换句话说,当前所有正在被调用的方法的引用类型的参数/局部变量/临时值。

Tracing GC的根本思路就是:给定一个集合的引用作为根出发,通过引用关系遍历对象图,能被遍历到的(可到达的)对象就被判定为存活,其余对象(也就是没有被遍历到的)就自然被判定为死亡。注意再注意:tracing GC的本质是通过找出所有活对象来把其余空间认定为“无用”,而不是找出所有死掉的对象并回收它们占用的空间。

对象的引用
无论是通过引用计数算法判断对象的引用数量,还是通过可达性分析算法判断对象的引用链是否可达,判定对象是否存活都与"引用有关"。

   JDK中分为四种引用类型:

 1、强引用

强引用就是指在我们程序代码之中普遍存在的,类似"Object obj = new Object()"这类引用。

2、软引用(SoftReference)

软引用用来描述一些还有用但非必须的对象,对于软引用关联的对象,在系统将要发生OOM(内存溢出异常)之前,将会把这些对象列进回收范围之中进行第二次回收,如果这次回收还没有足够的内存,才会抛出内存溢出异常。

3、弱引用(WeakReference)

弱引用也是用来描述非必需对象的,但是它的强度比软引用更弱一些,被弱引用关联对象只能生存到下一次垃圾收集之前,当垃圾收集器工作时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象

4、虚引用(PhantomReference)

虚引用也成为幽灵引用或者幻影引用,它是最弱的一种引用关系,一个对象是否有虚引用的存在,完全不会对其生存时间构成影响,也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。举个例子:Object obj 定义成虚引用,obj.是拿不到实例的,这个基本用不着。

代码示例

 软引用:
 


import java.lang.ref.SoftReference;
import java.util.LinkedList;
import java.util.List;
 
/**
 * @ClassName MyReferenceTest$
 * @Description TODO
 * @Author  QQ号:48793696
 * @date 2019/5/15 19:03
 * @Version 1.0
 **/
public class MySoftReferenceTest {
 
    public static class Employee {
        public int salary = 0;
        public String name = "";
 
 
        public Employee(int salary, String name) {
            super();
            this.salary = salary;
            this.name = name;
        }
 
        @Override
        public String toString() {
            return "Empolyee [name = " + name + ",salary = " + salary + "]";
        }
    }
 
    //VM参数:-Xms10m -Xmx10m -XX:+PrintGC
    public static void main(String[] args) {
        Employee e = new Employee(100, "allen");
        //软引用包装
        SoftReference<Employee> eSoft = new SoftReference<Employee>(e);
        e = null;
        System.out.println("=======beforeGC=============" + eSoft.get());
        System.gc();//演示如果内存足够,是不会回收SoftReference对象
        System.out.println("=======AfterGC=============" + eSoft.get());
 
        //模拟一个内存溢出的场景
        List<byte[]> list = new LinkedList<byte[]>();
 
        try {
            for (int i = 0; i < 100; i++) {
                System.out.println("**********************" + eSoft.get());
                list.add(new byte[1024*1024*1]);
            }
        } catch (Throwable e1) {
            System.out.println("======throwable========"+eSoft.get());
        }
    }
}

执行结果为;

我们看到软引用的对象,在系统将要发生OOM(内存溢出异常)之前,将会把这些对象列进回收范围之中进行第二次回收,如果这次回收还没有足够的内存,才会抛出内存溢出异常。我们看到了两次垃圾回收。

弱引用:

import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
 
/**
 * @ClassName MyWeakReferenceTest$
 * @Description TODO
 * @Author  QQ号:48793696
 * @date 2019/5/17 18:08
 * @Version 1.0
 **/
public class MyWeakReferenceTest {
    public static class Employee {
        public int salary = 0;
        public String name = "";
 
 
        public Employee(int salary, String name) {
            super();
            this.salary = salary;
            this.name = name;
        }
 
        @Override
        public String toString() {
 
            return "Empolyee [name = " + name + ",salary = " + salary + "]";
        }
    }
 
 
    public static void main(String[] args) {
        Employee e = new Employee(100, "allen");
        //弱引用包装
        WeakReference<Employee> eSoft = new WeakReference<Employee>(e);
        e = null;
        System.out.println("=======beforeGC=============" + eSoft.get());
        System.gc();//演示如果内存足够,是不会回收WeakReference对象
        System.out.println("=======AfterGC=============" + eSoft.get());
    }
}

执行结果为:

我们可以看到垃圾发生时,不管内存够不够都对弱引用进行回收。

软引用、弱引用使用场景:用在内存资源的情况下,缓存可以用强引用,二级缓存可以用弱引用。为什么一般使用强引用?因为资源一般都会够,软引用、弱引用时JDK2才出现的。

OOM内存溢出 1.案发现场他们有个mq消费者服务,在某一天下午,出现OOM了,导致服务直接挂掉。当时我们收到了很多内存的报警邮件。发现问题之后,运维第一时间,帮他们dump了当时的内存快照,之后,运维重启了该服务,系统暂时恢复了正常。 阅读详情

相关推荐

JVM内存溢出(OOM)的场景

JVM Memory线程私有区线程共享区程序计数器虚拟机栈本地方法栈堆内存方法区/元空间。

KBkongbaiKB的博客 1120

各种OOM的溢出实战及对象、布局、访问、对存活判断及引用

各种OOM的溢出实战及对象、布局、访问、对存活判断及引用 一、虚拟机中的对象 我们JAVA编程中无时无刻都在操作创建对象,那么我们虚拟机在遇到new关键词创建对象的执行过程是怎样的? 1、例如我们有一个User类首先检查是否存在这个User类,然后看是否有没有被加载过,如果没有加载JVM会先进行User加载。 2、加载完成后我们会在堆中分配特定大小的内存进行分配。 (...

soybean112的专栏 578

Jprofiler分析OOM内存溢出

先写一个堆溢出的程序: package com.lchtest; import java.util.ArrayList; import java.util.List; public class JvmSizeTest { public void testHeap(){//堆溢出 List<byte[]> list = new ArrayList<>(); int i=0; while (true){

weixin_41300437的博客 1760

JVM性能调优(九):OOM案例

`

mingyuli的博客 1346

Java 小白也能学会OOM内存溢出问题 排查分析

Java 小白也能学会OOM内存溢出问题 排查分析

默默不代表沉默 2122

SOC设计必看!Tessent DRC检查中最容易踩的5个坑(附解决方案)

本文针对SOC设计中Tessent DRC检查的常见问题,详细分析了5个最易忽视的陷阱,包括时钟域交叉、扫描链虚连、多电压域规则等,并提供专业解决方案。特别针对芯片设计中的DFT验证难点,分享了经过验证的调试方法和Tessent工具使用技巧,帮助工程师提升DRC检查效率。

weixin_29280657的博客 496

086、案例实战:每秒仅仅上百请求的系统为什么会因为OOM而崩溃?

案例实战:每秒仅仅上百请求的系统,为什么会因为OOM而崩溃?石杉老师最新出品:《C2C 电商系统微服务架构 120 天实战训练营》,点击了解详情儒猿架构官网上线,内有石杉老师架构课最新大纲,儒猿云平台详细介绍,敬请浏览官网:www.ruyuan2020.com(建议PC端访问)1、案例背景介绍本文将会给大家分析一个线上的真实生产案例,在这个案例中,一个每秒仅仅只有100+请求的系统却频繁的因为OOM而崩溃。在对这个案例进行深度分析的时候,大家会看到一个OOM问题是如何牵扯到Tomcat底层工作原理、Tom.

牵着蜗牛_去散步 799

Windows 2012 SYSVOL复制失败的处理

题外话:晓原理、知架构、查日志是排错的三件法宝今天在DC1上新建并链接了一个组策略对像,在客户端刷新时,却报下面的错误:“处理组策略失败。Windows无法应用组策略对象LDAP….”如下图所示:于是在客户端用\\domain.com访问,发现\\domain.com\SYSVOL\domain.com\policies下面没有上面报错的组策略对象。这是怎么一回事呢,pin...

weixin_33989780的博客 1672

mybatis批量插入数据导致系统OOM,微服务内存爆了

今天我们来说说工作中遇到的一个真实案例,由于使用mybatis的批量插入功能,导致系统内存溢出OOM(Out Of Memory), "java.lang.OutOfMemoryError: Java heap space"的报错,导致服务出现短暂的服务不可用,大概一两分钟不可用。1) 上面写的阈值1000 ,需要根据自己的业务场景来设置,比如你插入对象简单,对象属性不读,也不复杂,单个对象的大小也不超过1kb,那你这里的阈值可以设置大些,比如2000, 甚至 可以是 10000;

xzb5566的专栏 4523

Token算力工厂建设方案:从GPU集群到计量计费的全链路设计

在AI应用从“租核”走向“买Token”的范式转换中,算力交付的核心指标已不再是vCPU或GPU实例,而是单位时间内的Token产出量与单Token成本。这一变化推动基础设施从资源租赁向计件生产演进,要求GPU集群、推理引擎、调度系统、计量计费等模块像工厂产线一样协同运转。本文从硬件异构混部、存储网络设计、推理引擎调优、Token网关与配额管理、稳定性治理等维度,系统拆解如何构建一座可量化、可计费、可扩展的Token算力工厂,并给出分三期落地的推进节奏,帮助架构师与技术管理者在AI基础设施建设中实现成本可控

weixin_29095587的博客 267

手把手教你用Python实现最简单的语义通信(Sem Comm)Demo

本文通过Python和PyTorch,手把手教你构建一个基于深度学习的语义通信(Semantic Communication)Demo。该Demo使用自编码器架构,从MNIST图像中提取低维语义特征进行传输与重建,实现了从“传输比特”到“传递含义”的跨越,并探讨了其效率优势与鲁棒性。

weixin_29080843的博客 247

内存溢出oom——生产真实案例分析,max-http-header-size配置不当

内存溢出oom——生产真实案例分析,max-http-header-size引发的生产问题

zhangkaixuan456的博客 2439

【数字孪生与仿真技术】10:半导体制造中的虚拟量测技术深度解析:从多尺度建模到工业级应用

摘要:半导体制造过程中,晶圆加工需实时监测300+关键参数,传统物理量测技术面临产能损耗、延迟检测等痛点。本文系统阐述虚拟量测(Virtual Metrology)技术的完整解决方案,通过多尺度混合建模实现物理机理与数据驱动的深度融合。内容涵盖等离子体刻蚀、薄膜沉积等关键工艺的物理模型构建,LSTM神经网络的数据校正算法,以及边缘-云协同的实时部署架构。某12英寸晶圆厂实践表明,虚拟量测技术可减少70%物理量测频次,异常漏检率从18%降至3%,机台利用率提升11%。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 2558

【Java开发】之 OOM 内存溢出

OOM,全称 Out Of Memory,意思是内存耗尽或内存溢出。对应Java 程序抛出的错为,这个错误在官方的解释如下:意思就是说,当 JVM 因为没有足够的内存来为对象分配空间并且垃圾回收器也已经没有空间可回收时,就会抛出这个 error(注意:这错误并非 exception,因为这个问题已经严重到不足以被应用处理)。

王廷云的博客 1589

innovus中如何设置cts参数

上面是设置cts的一般设置,如果需要对某些skew group或者某些clock tree设置不一样的参数,如需要对clk1这个clock设置不一样的inverter,可以使用。需要查询已经设置过的ccopt参数,可以使用get_ccopt_property去查询,方法和set_ccopt_property一致。言归正传,cts的设置命令是set_ccopt_property,获取命令是get_ccopt_property。另外,set_ccopt_property提供一套命令查询方法。

芯冰乐 548

【KingSCADA】如何建立硬件系统及相关变量

本篇主要讲解如何定义设备,如何定义变量。KingSCADA3.8的采集系统是指负责和现场设备进行通讯,并采集现场数据和控制现场数据的模块,称之为采集器,也叫IOServer应用,它是一组独立的应用程序,可以脱离KingSCADA3.8软件,它依赖于KingSCADA3.8驱动产品,通过驱动与IO设备进行通讯。采集系统由通讯链路,设备,数据块组成。链路:链路是指计算机通过什么方式(接口)与设备进行连接,链路类别:串口,以太网,GPRS,Modem,通信卡,采集卡,无链路。

做有价值的事,积累有价值的笔记! 1万+

OOM内存溢出汇总

OOM内存溢出汇总 http://hellojava.info/?p=319 CASE1 一.出现问题 在前一段时间日常环境很不稳定,前端调用接口会出网络异常或服务不存在的异常。查询了服务器上的服务会有偶尔挂死的情况,服务器上的接口服务都不可用。于是我们对服务器上的状况进行了排查。 二.排查问题的过程 三.排查问题的步骤 1.查看服务器大概情况 首先最容易想到的是top命令,...

maso88的专栏 7607

Autosar MCAL-S32k324 Crypto配置-基于EB

NXP官网提供了免费的HSE固件,同时也提供了对应的协议栈。本文以算法为例,介绍MCAL相关的配置及在代码中的集成与使用。使用HSE计算,比软件算法确实方便许多。后面会完善更多的算法测试。

赞的博客 2436

OOM的原因到底是内存泄漏还是内存溢出?

是指应用程序在运行过程中,无法从操作系统分配到足够的内存,从而导致程序崩溃或异常终止。Java应用程序:抛出。Linux系统:触发OOM Killer,强制终止占用内存过多的进程。容器环境:如Docker容器因内存限制而崩溃。内存泄漏是指应用程序分配的内存未能正确释放,导致内存使用量持续增长。内存溢出是指应用程序一次性申请的内存超过了可用内存,导致无法分配所需内存。OOM的原因既可能是内存泄漏,也可能是内存溢出,还可能是其他因素(如资源竞争、外部依赖问题)。

秃头之旅 1429

深度学习工具包 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")

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

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

一文彻底搞懂OOM内存溢出问题

OOM是Out Of Memory的缩写。即内存溢出。OOM通常是由于程序消耗的内存超过了系统实际可用的内存资源,或者是内存泄漏导致的。OOM错误会导致程序异常终止,通常会在日志或控制台中输出相关错误信息,包括堆栈跟踪等,以便开发人员进行排查和修复。解决OOM问题通常需要对程序进行内存使用情况的分析,优化代码逻辑,释放不必要的内存资源,增加系统内存配置等措施。

永远在路上 7607

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

kafka 排查内存溢出_内存溢出[OOM]异常快速定位排查

什么是OOM?就是我们常见的:java.lang.OutOfMemoryError,在应用开发中,是比较常见的一种异常,主要分为三种:OutOfMemoryError:PermGen spaceOutOfMemoryError:Java heap spaceOutOfMemoryError:unable to create new native thread内存泄露 和 内存溢出 的...

weixin_36076701的博客 4113

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

探寻内存溢出(OOM)

OOM为out of memory的简称,称之为内存溢出,来源于java.lang.OutOfMemoryError。当JVM因为没有足够的内存来为对象分配空间并且垃圾回收器也已经没有空间可回收时,就会抛出这个error(注:非exception,因为这个问题已经严重到不足以被应用处理)。 既然是内存溢出,那我们就先看看JVM有哪些内存区间。之前文章提到过,Java虚拟机在运......

zsh2050的专栏 1430

【Java】常见内存溢出OOM

内存溢出: out of memory,OOM,全称“Out Of Memory”,翻译成中文就是“内存用完了”,来源于。看下关于的官方说明:意思就是说,当JVM因为没有足够的内存来为对象分配空间并且垃圾回收器也已经没有空间可回收时,就会抛出这个error(注:非exception,因为这个问题已经严重到不足以被应用处理)。是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory;比如申请了一个integer,但给它存了long才能存下的数,那就是内存溢出。

DreamSun的博客 933

Java 内存溢出排查优化实战:彻底干掉臭名昭著的 OOM

OutOfMemoryError,也就是臭名昭著的 OOM(内存溢出),相信很多球友都遇到过,相对于常见的业务异常,如数组越界、空指针等,OOM 问题 更难难定位和解决。 这篇内容就以之前碰到的一次线上内存溢出的定位、解决问题的方式展开;希望能对碰到类似问题的球友带来思路和帮助。 主要从表现-->排查-->定位-->解决 四个步骤来分析和解决问题。

在技术的广袤天地里,本博客如精准罗盘。剖析前沿科技,深掘代码奥秘,以精炼笔触,带您穿越复杂技术迷宫,速达知识彼岸。 1808

Redis内存管理相关问题——内存溢出(OOM)问题及解决方案

Redis内存管理相关问题——内存溢出(OOM)问题及解决方案

专注分享技术、实用优质教程、资源 1334

OOM内存溢出的原因总结

OOM是Out of Memory的缩写,意思是内存溢出。它是指程序在申请内存时,系统可分配的内存已不足,从而导致程序运行失败。

guo20082200的博客 999
上一篇: 消息中间件如何确保消息100%投递成功及消息的幂等性设计
下一篇: Kafka、ActiveMQ、RabbitMQ、RocketMQ 都有什么区别,以及适合哪些场景?
Jack爱258
博客等级 码龄10年 1288粉丝 124原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值