精华内容
下载资源
问答
  • 主要介绍了java内存泄漏与内存溢出关系解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory;比如申请了一个integer,但给它存了long才能存下的数,那就是内存溢出。内存泄露 memory leak,是指程序在申请内存...

    内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory;比如申请了一个integer,但给它存了long才能存下的数,那就是内存溢出。

    内存泄露 memory leak,是指程序在申请内存后,无法释放已申请的内存空间,一次内存泄露危害可以忽略,但内存泄露堆积后果很严重,无论多少内存,迟早会被占光。

    memory leak会最终会导致out of memory!

    内存溢出就是你要求分配的内存超出了系统能给你的,系统不能满足需求,于是产生溢出。

    内存泄漏是指你向系统申请分配内存进行使用(new),可是使用完了以后却不归还(delete),结果你申请到的那块内存你自己也不能再访问(也许你把它的地址给弄丢了),而系统也不能再次将它分配给需要的程序。一个盘子用尽各种方法只能装4个果子,你装了5个,结果掉倒地上不能吃了。这就是溢出!比方说栈,栈满时再做进栈必定产生空间溢出,叫上溢,栈空时再做退栈也产生空间溢出,称为下溢。就是分配的内存不足以放下数据项序列,称为内存溢出.

    以发生的方式来分类,内存泄漏可以分为4类:

    1. 常发性内存泄漏。发生内存泄漏的代码会被多次执行到,每次被执行的时候都会导致一块内存泄漏。

    2. 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境,偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。

    3. 一次性内存泄漏。发生内存泄漏的代码只会被执行一次,或者由于算法上的缺陷,导致总会有一块仅且一块内存发生泄漏。比如,在类的构造函数中分配内存,在析构函数中却没有释放该内存,所以内存泄漏只会发生一次。

    4. 隐式内存泄漏。程序在运行过程中不停的分配内存,但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏,因为最终程序释放了所有申请的内存。但是对于一个服务器程序,需要运行几天,几周甚至几个月,不及时释放内存也可能导致最终耗尽系统的所有内存。所以,我们称这类内存泄漏为隐式内存泄漏。

    从用户使用程序的角度来看,内存泄漏本身不会产生什么危害,作为一般的用户,根本感觉不到内存泄漏的存在。真正有危害的是内存泄漏的堆积,这会最终消耗尽系统所有的内存。从这个角度来说,一次性内存泄漏并没有什么危害,因为它不会堆积,而隐式内存泄漏危害性则非常大,因为较之于常发性和偶发性内存泄漏它更难被检测到

    展开全文
  • java内存泄露与内存溢出 基本概念 内存泄露:指程序中动态分配内存给一些临时对象,但是对象不会被GC所回收,它始终占用内存。即被分配的对象可达但已无用。 内存溢出:指程序运行过程中无法申请到足够的内存而...

    java内存泄露与内存溢出

    基本概念

    内存泄露:指程序中动态分配内存给一些临时对象,但是对象不会被GC所回收,它始终占用内存。即被分配的对象可达但已无用。

    内存溢出:指程序运行过程中无法申请到足够的内存而导致的一种错误。内存溢出通常发生于OLD段或Perm段垃圾回收后,仍然无内存空间容纳新的Java对象的情况。

    从定义上看,内存泄露是内存溢出的一种诱因,不是唯一因素。

    JAVA中的内存泄露

        Java中的内存泄露,广义并通俗的说,就是:不再会被使用的对象的内存不能被回收,就是内存泄露。Java中的内存泄露与C++中的表现有所不同。在C++中,所有被分配了内存的对象,不再使用后,都必须程序员手动的释放他们。所以,每个类,都会含有一个析构函数,作用就是完成清理工作,如果我们忘记了某些对象的释放,就会造成内存泄露。

        但是在Java中,我们不用(也没有办法)自己释放内存,无用的对象由GC自动清理,这也极大的简化了我们的编程工作。但实际有时候一些不再会被使用的对象,在GC看来不能被释放,就会造成内存泄露。内存泄露的根本原因:长生命周期的对象持有短生命周期对象的引用。我们知道,对象都有生命周期的,有的长,有的短,如果长生命周期的对象持有短生命周期的引用,就很可能会出现内存泄露。下面给出了内存泄露中的一些例子:

    全局变量缓存局部变量,且没有清空操作造成内存泄露

    这里的object实例,其实我们期望它只作用于method1()方法中,且其他地方不会再用到它,但是,当method1()方法执行完成后,object对象所分配的内存不会马上被认为是可以被释放的对象,只有在Simple类创建的对象被释放后才会被释放,严格的说,这就是一种内存泄露。解决方法就是将object作为method1()方法中的局部变量。当然,如果一定要这么写,可以改为这样:

    这样,之前"new Object()"分配的内存,就可以被GC回收。

    容器使用时的内存泄露

    各种提供close()方法的对象

    比如数据库连接(dataSourse.getConnection()),网络连接(socket)和io连接,以及使用其他框架的时候,除非其显式的调用了其close()方法(或类似方法)将其连接关闭,否则是不会自动被GC回收的。其实原因依然是长生命周期对象持有短生命周期对象的引用。

    单例模式导致的内存泄露

    单例模式,很多时候我们可以把它的生命周期与整个程序的生命周期看做差不多的,所以是一个长生命周期的对象。如果这个对象持有其他对象的引用,也很容易发生内存泄露。

    JAVA中的内存溢出

    堆相关内存溢出

    outOfMemoryError: java heap space

    在jvm规范中,堆中的内存是用来生成对象实例和数组的。如果细分,堆内存还可以分为年轻代和老年代,年轻代包括一个eden区和两个survivor区。当生成新对象时,内存的申请过程如下:

    1. jvm先尝试在eden区分配新建对象所需的内存
    2. 如果内存大小足够,申请结束,否则下一步
    3. jvm启动youngGC试图将eden区中不活跃的对象释放掉,释放后若eden空间仍然不足以放入新对象,则试图将部分Eden中活跃对象放入Survivor区
    4. Surivior区被用来作为Eden及old的中间交换区域,当old区域空间足够时,Survivor区的对象将会被移到old区,否则会被保留在Survivor区
    5. 当old区域空间不够时,JVM会在old区进行full GC
    6. full GC后,若Survivor及old区仍然无法存放从Eden复制过来的部分对象,导致JVM无法在Eden区为新对象创建内存区域,则会出现"out of memory错误"

    解决办法

    • 将堆内存 dump 下来,使用 MAT 分析一下,解决内存泄漏;
    • 如果没有内存泄漏,使用 -Xmx 增大堆内存;
    • 如果有自定义的 Finalizable 对象,考虑其存在的必要性。

     

    java.lang.OutOfMemoryError:GCoverheadlimitexceeded

        JDK6新增错误类型,当GC为释放很小空间占用大量时间抛出;一般是因为堆太小,导致异常的原因,没有足够的内存。

    解决方法:

    1. 查看系统是否使用大内存的代码或死循环
    2. 通过添加JVM配置,来限制使用内存:-XX:-UseGCOverheadLimit

     

     

    方法区内存溢出

    outOfMemoryError: permgem space

    在jvm规范中,方法区主要存放的是类信息、常量、静态变量等

    报错原因

    永久代是 HotSot 虚拟机对 方法区的具体实现,存放了已被虚拟机加载的类信息、常量、静态变量、JIT编译后的代码等。需要注意的是,在Java8后,永久代有了一个新名字:元空间,元空间使用的是本地内存。永久代里存在的信息也有了若干变化:

    • 字符串常量由永久代转移到堆中;
    • 和永久代相关的JVM参数已移除。

    出现永久代或元空间的溢出的原因可能有如下几种:

    • 有频繁的常量池操作(eg. String.intern),这种情况只适用于Java7之前应用;
    • 加载了大量的类信息,且没有及时卸载;
    • 应用部署完后没有重启。

     

    这种事Perm区内存不够,可通过调整JVM的配置:

    -XX:MaxPermSize=128m

    -XX:PermSize=128m

    设置永久区的初始空间和最大空间

    -XX:PermSize设置持久代(perm gen)初始值,物理内存的1/64

    -XX:MaxPermSize设置持久代最大值,物理内存的1/4

     

    线程栈溢出

    java.lang.StackOverflowError

    线程栈是线程独有的一块内存结构,所以线程栈发生问题必定是某个线程运行时发生的错误。

    一般线程栈溢出是由于递归太深或方法调用层级过多导致的。

    发生栈溢出的错误信息为:

    解决方法:优化程序设计,减少方法调用层次;调整-Xss参数增加线程栈大小

     

    java.lang.OutOfMemoryError.unabletocreatenewnativethread

    Stack空间不足以创建额外的线程,要么创建的线程过多,要么Stack空间确实小了。

    解决:由于JVM没有提供参数设置总的stack空间大小,但可以设置单个线程栈的大小;而系统的用户空间一共是3G,除了Text/Data/BSS/MemoryMapping几个段之外,Heap和Stack空间的总量有限,是此消彼长的。因此遇到这个错误,可以通过两个途径解决:1.通过-Xss启动参数减少单个线程栈大小,这样便能开更多线程(当然不能太小,太小会出现StackOverflowError);2.通过-Xms-Xmx两参数减少Heap大小,将内存让给Stack(前提是保证Heap空间够用)。

     

    本地方法溢出

    java.lang.OutOfMemoryError: stack_trace_with_native_method

    这种情况表明,本地方法在运行时出现了内存分配失败。和java.lang.OutOfMemoryError : unable to create new native Thread 保存不同,方法栈溢出出现在 JVM 的代码层面,而本地方法溢出发生在JNI代码或本地方法处。

     

    java内存泄露排查

    JVM如果出现内存泄露,典型的现象就是系统FullGC比较频繁。到最后干脆OOM(Out of Memory)了。

    当发现应用内存溢出或长时间使用内存很高的情况下,通过内存dump进行分析可找到原因。当发现cpu使用率很高时,通过线程dump定位具体哪个线程在做哪个工作占用了过多的资源。内存dump是指通过jmap -dump <pid>输出的文件,而线程dump是指通过jstack <pid>输出的信息。在linux操作系统下(已安装jdk),执行jps命令,列出正在运行的java程序的进程ID。

    使用top查看目前正在运行的进程使用系统资源情况。

    首先是内存dump:

    jmap –dump:live,format=b,file=heap.bin <pid>
    

    其次是线程dump,比如说::

    jstack -m <pid> >jvm_deadlocks.txt
    
    jstack -l <pid> >jvm_listlocks.txt
    

    但是dump堆要花较长的时间,并且文件巨大,再从服务器上拖回本地导入工具,这个过程太折腾不到万不得已最好别这么干。

    可以用更轻量级的在线分析,用jmap查看存活的对象情况(jmap -histo:live [pid])。

    比如上图所示,HashTable占用了大量的内存,如何找到导致这个事情发生的原因?可以进一步使用btrace来排查。

     

    JvisualVM

    VisualVM 是Netbeans的profile子项目,已在JDK6.0 update 7 中自带,能够监控线程,内存情况,查看方法的CPU时间和内存中的对 象,已被GC的对象,反向查看分配的堆栈(如100个String对象分别由哪几个对象分配出来的)。在JDK_HOME/bin(默认是C:\Program Files\Java\jdk1.6.0_13\bin)目录下面,有一个jvisualvm.exe文件,双击打开,从UI上来看,这个软件是基于NetBeans开发的了。

    VisualVM 提供了一个可视界面,用于查看 Java 虚拟机 (Java Virtual Machine, JVM) 上运行的基于 Java 技术的应用程序的详细信息。VisualVM 对 Java Development Kit (JDK) 工具所检索的 JVM 软件相关数据进行组织,并通过一种使您可以快速查看有关多个 Java 应用程序的数据的方式提供该信息。您可以查看本地应用程序或远程主机上运行的应用程序的相关数据。此外,还可以捕获有关 JVM 软件实例的数据,并将该数据保存到本地系统,以供后期查看或与其他用户共享。

    展开全文
  • JAVA中的内存溢出和内存泄漏分别是什么,有什么联系和区别,我谈谈自己的理解。内存泄漏(memoryleak):申请了内存不释放,比如100m的内存,分配了10m的内存一直不回收,那么可以用的内存只有90m了,仿佛泄露掉了一...

    JAVA中的内存溢出和内存泄漏分别是什么,有什么联系和区别,我谈谈自己的理解。

    内存泄漏(memory leak ):申请了内存不释放,比如100m的内存,分配了10m的内存一直不回收,那么可以用的内存只有90m了,仿佛泄露掉了一部分;通俗一点讲的话就是【占着茅坑不拉shi】。

    内存溢出(out of memory):申请内存时,没有足够的内存可以使用;通俗一点儿讲,一个厕所就三个坑,有两个站着茅坑不走的,剩下最后一个表示压力很大,这时候一下子来了两个人,坑位(内存)就不够了。

    内存泄漏和内存溢出的关系:内存泄露的增多,最终会导致内存溢出。

    0a37c1f55740deb571d8ac7249e8e7e8.png

    这是一个很有味道的例子......

    如上图,对象X引用对象Y,X的生命周期为60,Y的生命周期为20,当Y生命周期结束的时候,X依然引用着B,这时候,垃圾回收期是不会回收对象Y的;如果对象X还引用着生命周期比较短的A、B、C...对象A又引用着对象a、b、c...

    那么就可能造成大量无用的对象不能被回收,进而占据了内存资源,造成内存泄漏,直到内存溢出。

    内存泄漏的分类

    经常(不断)发生:发生内存泄露的代码会被多次执行,每次执行,泄露一块内存;

    偶然发生:在某些特定情况下才会发生;

    一次性:发生内存泄露的方法只会执行一次;

    55063856537f79b1201b28dcdc0c2eaa.png

    隐式泄露:一直占着内存不释放,直到执行结束;严格的说这个不算内存泄露,因为最终释放掉了,但是如果执行时间特别长,也可能会导致内存耗尽。

    内存泄露产生的可能原因

    循环过多或死循环,产生大量对象;

    静态集合类引起内存泄漏,因为静态集合的生命周期和应用一致,所以静态集合引用的对象不能被释放;

    单例模式,和静态集合导致内存泄露的原因类似;

    事件监听(listeners)和回调(callbacks);

    各种连接,比如数据库连接、Socket连接、IO等,必须显式释放(close);

    dce466831eeff2a2e9a359356dc32642.png

    内存中加载数据量过大;我之前项目有一次上线的时候,应用启动奇慢直到夯死,就是因为代码中会加载一个表中的数据到缓存(内存)中,测试环境只有几百条数据,但是生产环境有几百万的数据。

    展开全文
  • 主要介绍了Java虚拟机内存溢出与内存泄漏,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java内存溢出&内存泄漏

    千次阅读 2019-04-21 14:10:55
    为了解决Java内存溢出问题,我们首先必须了解Java是如何管理内存的。Java的内存管理就是对象的分配和释放问题。 在Java中,内存的分配是由程序完成的,而内存的释放是由垃圾收集器(GarbageCollection,GC)完成的,...

    内存溢出

    1. 定义及原因
    内存溢出是指应用系统中存在无法回收的内存或使用的内存过多,最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。
    为了解决Java中内存溢出问题,我们首先必须了解Java是如何管理内存的。Java的内存管理就是对象的分配和释放问题。
    在Java中,内存的分配是由程序完成的,而内存的释放是由垃圾收集器(GarbageCollection,GC)完成的,程序员不需要通过调用GC函数来释放内存,因为不同的JVM实现者可能使用不同的算法管理GC,有的是内存使用到达一定程度时,GC才开始工作,也有定时执行的,有的是中断式执行GC。但GC只能回收无用并且不再被其它对象引用的那些对象所占用的空间。
    Java的内存垃圾回收机制是从程序的主要运行对象开始检查引用链,当遍历一遍后发现没有被引用的孤立对象就作为垃圾回收。

    引起内存溢出的原因有很多种,常见的有以下几种:

    1. 内存中加载的数据量过于庞大,如一次从数据库取出过多数据;
    2. 集合类中有对对象的引用,使用完后未清空,使得JVM不能回收;
    3. 代码中存在死循环或循环产生过多重复的对象实体;
    4. 使用的第三方软件中的BUG;
    5. 启动参数内存值设定的过小

    2. 解决方法
    内存溢出虽然很棘手,但也有相应的解决办法,可以按照从易到难,一步步的解决。

    第一步,就是修改JVM启动参数,直接增加内存。
    这一点看上去似乎很简单,但很容易被忽略。JVM默认可以使用的内存为64M,Tomcat默认可以使用的内存为128MB,对于稍复杂一点的系统就会不够用。在某项目中,就因为启动参数使用的默认值,经常报“OutOfMemory”错误。因此,-Xms,-Xmx参数一定不要忘记加。

    第二步,检查错误日志,查看“OutOfMemory”错误前是否有其它异常或错误。
    在一个项目中,使用两个数据库连接,其中专用于发送短信的数据库连接使用DBCP连接池管理,用户为不将短信发出,有意将数据库连接用户名改错,使得日志中有许多数据库连接异常的日志,一段时间后,就出现“OutOfMemory”错误。经分析,这是由于DBCP连接池BUG引起的,数据库连接不上后,没有将连接释放,最终使得DBCP报“OutOfMemory”错误。经过修改正确数据库连接参数后,就没有再出现内存溢出的错误。
    查看日志对于分析内存溢出是非常重要的,通过仔细查看日志,分析内存溢出前做过哪些操作,可以大致定位有问题的模块。

    第三步,安排有经验的编程人员对代码进行走查和分析,找出可能发生内存溢出的位置。重点排查以下几点:
     检查代码中是否有死循环或递归调用。
     检查是否有大循环重复产生新对象实体。
     检查对数据库查询中,是否有一次获得全部数据的查询。一般来说,如果一次取十万条记录到内存,就可能引起内存溢出。这个问题比较隐蔽,在上线前,数据库中数据较少,不容易出问题,上线后,数据库中数据多了,一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。
     检查List、MAP等集合对象是否有使用完后,未清除的问题。List、MAP等集合对象会始终存有对对象的引用,使得这些对象不能被GC回收。

    第四步,使用内存查看工具动态查看内存使用情况。
    某个项目上线后,每次系统启动两天后,就会出现内存溢出的错误。这种情况一般是代码中出现了缓慢的内存泄漏,用上面三个步骤解决不了,这就需要使用内存查看工具了。

    内存查看工具有许多,比较有名的有:Optimizeit Profiler、JProbeProfiler、JinSight和Java1.5的Jconsole等。它们的基本工作原理大同小异,都是监测Java程序运行时所有对象的申请、释放等动作,将内存管理的所有信息进行统计、分析、可视化。开发人员可以根据这些信息判断程序是否有内存泄漏问题。
    一般来说,一个正常的系统在其启动完成后其内存的占用量是基本稳定的,而不应该是无限制的增长的。持续地观察系统运行时使用的内存的大小,可以看到在内存使用监控窗口中是基本规则的锯齿形的图线,如果内存的大小持续地增长,则说明系统存在内存泄漏问题。通过间隔一段时间取一次内存快照,然后对内存快照中对象的使用与引用等信息进行比对与分析,可以找出是哪个类的对象在泄漏。

    通过以上四个步骤的分析与处理,基本能处理内存溢出的问题。当然,在这些过程中也需要相当的经验与敏感度,需要在实际的开发与调试过程中不断积累。

    3. 优化代码
    内存容易溢出可以说是因为在程序中有内存泄漏(memory leak)的问题,容易引起内存溢出的直接原因可以归结为代码质量问题,在内存中存在大量的对象,垃圾回收器不能回收,随着程序的不断运行,程序会创造更多的对象,这些对象之间存在一定的内联关系,所以不容易造成被java垃圾回收器回收。

    解决的办法:
    第一对所有的代码包括页面中的java代码都进行一遍彻底的回顾检查,
    1.对那些静态(static)的对象要特别留神,特别是类型为Map,List,Set的,静态的变量会一直驻存在内存中,生命周期比较长,不会被垃圾器回收。

    2.对于代码,要审查是否生成了大量的冗余的对象,还有一些逻辑业务处理的类,
    算法是否过于复杂,调整算法,对于代码认真审查,再仔细重构一遍代码,能提高代码质量,提高程序运行稳定性。

    3.Java中的内存溢出大都是因为栈中的变量太多了。其实内存有的是。建议不用的尽量设成null以便回收,多用局部变量,少用成员变量。
    1)变量所包含的对象体积较大,占用内存较多。
    2)变量所包含的对象生命周期较长。
    3)变量所包含的对象数据稳定。
    4)该类的对象实例有对该变量所包含的对象的共享需求。

    4.在我的程序中对静态变量的优化后,使程序占用内存量至少提升了5k-10k。所以也不容忽视。

    第二还有就是String类相关的东西:
    1.字符串累加的时候一定要用StringBuffer的append方法,不要使用+操作符连接两个字符串。差别很大。而且在循环或某些重复执行的动作中不要去创建String对象,因为String对象是要用StringBuffer对象来处理的,一个String对象应该是产生了 3个对象(大概是这样:))。

    2.字符串length()方法来取得字符串长度的时候不要把length放到循环中,可以在循环外面对其取值。(包括vector的size方法)。特别是循环次数多的时候,尽量把length放到循环外面。

    int size = xmlVector.size();
    for (int i = 2; i < size; i++) {
    。。。
        }
           3 写代码的时候处理内存溢出   
             try{   
                //do   sth   
      ....   
             }catch   (outofmemoryerror   e){//可以用一个共通函数来执行.   
              system.out.print   (“no   memory!   ”);   
              system.gc();   
               //do   sth   again   
            ....   
             }      
    

    4.对于频繁申请内存和释放内存的操作,还是自己控制一下比较好,但是System.gc()的方法不一定适用,最好使用finallize强制执行或者写自己的finallize方法。
    Java 中并不保证每次调用该方法就一定能够启动垃圾收集,它只不过会向JVM发出这样一个申请,到底是否真正执行垃圾收集,一切都是个未知数。

    内存泄露
    1. 定义及原因
    内存泄漏(memory leak),在大型的、复杂的应用程序中,内存泄漏是常见的问题。当以前分配的一片内存不再需要使用或无法访问时,但是却并没有释放它,那么对于该进程来说,会因此导致总可用内存的减少,这时就出现了内存泄漏。尽管优秀的编程实践可以确保最少的泄漏,但是根据经验,当使用大量的函数对相同的内存块进行处理时,很可能会出现内存泄漏。尤其是在碰到错误路径的情况下更是如此。

    一般我们常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的,大小任意的(内存块的大小可以在程序运行期决定),使用完后必须显式释放的内存。应用程序一般使用malloc,realloc,new等函数从堆中分配到一块内存,使用完后,程序必须负责相应的调用free或delete释放该内存块,否则,这块内存就不能被再次使用,我们就说这块内存泄漏了。
    总结:内存泄露就是堆内存分配的对象空间,没有被GC正常回收,导致内存释放不了,最终会导致内存不足,溢出

    Java内存泄漏引起的原因:
      内存泄漏是指无用对象(不再使用的对象)持续占有内存或无用对象的内存得不到及时释放,从而造成内存空间的浪费称为内存泄漏。
      长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄漏,尽管短生命周期对象已经不再需要,但是因为长生命周期持有它的引用而导致不能被回收,这就是Java中内存泄漏的发生场景。

    造成内存泄漏的几种情况:
    1、静态集合类引起内存泄漏
      像HashMap、Vector等的使用最容易出现内存泄露,这些静态变量的生命周期和应用程序一致,他们所引用的所有的对象Object也不能被释放,因为他们也将一直被Vector等引用着。

    2、当集合里面的对象属性被修改后,再调用remove()方法时不起作用

    3、监听器
    在释放对象的时候却没有去删除这些监听器,增加了内存泄漏的机会。

    4、各种连接
    比如数据库连接(dataSourse.getConnection()),网络连接(socket)和io连接,除非其显式的调用了其close()方法将其连接关闭,否则是不会自动被GC 回收的。

    5、内部类和外部模块的引用
    内部类的引用是比较容易遗忘的一种,而且一旦没释放可能导致一系列的后继类对象没有释放。此外程序员还要小心外部模块不经意的引用,例如程序员A 负责A 模块,调用了B 模块的一个方法如: public void registerMsg(Object b); 这种调用就要非常小心了,传入了一个对象,很可能模块B就保持了对该对象的引用,这时候就需要注意模块B 是否提供相应的操作去除引用。

    6、单例模式
    不正确使用单例模式是引起内存泄漏的一个常见问题,单例对象在初始化后将在JVM的整个生命周期中存在(以静态变量的方式),如果单例对象持有外部的引用,那么这个对象将不能被JVM正常回收,导致内存泄漏。

    https://www.cnblogs.com/yl-saber/p/6907517.html
    https://www.cnblogs.com/holdon521/p/4409046.html

    展开全文
  • Java 内存溢出和内存泄漏的区别 内存溢出 out of memory 是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory;比如申请了一个integer,但给它存了long才能存下的数,那就是内存溢出。 内存...
  • 1、内存溢出 内存溢出
  • 主要介绍了Java内存溢出和内存泄露的相关资料,需要的朋友可以参考下
  • 文章目录一、概念的区分二、内存溢出的原因以及解决方法2.1、内存溢出的原因2.2、内存溢出的解决方案:三、内存泄漏3.1、内存泄漏的分类:3.2、内存泄漏的危害 一、概念的区分 内存溢出 out of memory,是指程序在...
  • Java内存泄漏与内存溢出详解

    千次阅读 2017-02-04 21:08:08
    内存泄漏指你用malloc或new申请了一块内存,但是没有通过free或delete将内存释放,导致这块内存一直处于占用状态。...内存溢出指你申请了10个字节的空间,但是你在这个空间写入11或以上字节的数据,就是溢出。
  • java内存泄漏内存溢出

    千次阅读 2018-09-28 23:05:51
    java内存泄漏内存溢出 概念 a)内存泄露:被分配对象可达但无用 b)内存溢出:无法申请到足够的内存而产生的错误 内存泄漏场景 a)创建和应用生命周期一样的单例对象 b)创建匿名内部类的静态对象 c)未关闭资源 ...
  • java内存泄露溢出检查方法和工具。 步骤: 1,使用linux命令生存堆栈文件 2,用MemoryAnalyzer.exe工具打开 3,根据工具生成的饼状图可以清晰的找出内存泄漏
  • 内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory;java.lang.OutOfMemoryError,是指程序在申请内存时,没有足够的内存空间供其使用,出现OutOfMemoryError。原因...
  • 参考文章:https://www.ibm.com/developerworks/cn/java/l-JavaMemoryLeak/ ...Java内存泄漏 问题的提出 Java的一个重要优点就是通过垃圾收集器(Garbage Collection,GC)自动管理内存的回收,...
  • JAVA内存泄漏内存溢出的区别和联系

    万次阅读 多人点赞 2018-03-14 17:25:04
    JAVA内存泄漏内存溢出的区别和联系 1、内存泄漏memory leak : 是指程序在申请内存后,无法释放已申请的内存空间,一次内存泄漏似乎不会有大的影响,但内存泄漏堆积后的后果就是内存溢出。 2、内存溢出 out ...
  • 浅谈Java内存泄漏内存溢出的区别

    千次阅读 2019-04-03 19:15:00
    浅谈Java内存泄漏内存溢出的区别 内存溢出 out of memory是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory 内存泄露 memory leak是指程序在申请内存后,无法释放已申请的内存空间,一次内存...
  • java内存泄漏与内存溢出 内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory; 内存泄露 memory leak,是指程序在申请内存后,无法释放已申请的内存空间,一次内存...
  • 1、 内存溢出的原因是什么?内存溢出是由于没被引用的对象(垃圾)过多造成JVM没有及时回收,造成的内存溢出。如果出现这种现象可行代码排查:一)是否应用中的类中和引用变量过多使用了Static修饰 如public staitc ...
  • 模拟Java内存溢出

    2021-03-16 21:38:10
    本文通过修改虚拟机启动参数,来剖析常见的java内存溢出异常(基于jdk1.8)。修改虚拟机启动参数这里我们使用的是IDEA集成开发环境,选择Run/Debug Configurations然后选择Configuration,修改VM options配置,就可以...
  • java内存溢出 原因排查方法 1、 内存溢出的原因是什么? 内存溢出是由于没被引用的对象(垃圾)过多造成JVM没有及时回收,导致剩余的内存不够用,造成的内存溢出。如果出现这种现象可行代码排查: 一)是否应用...
  • 内存溢出 方法入栈后,其中的局部变量逐渐增长,一直不释放,导致堆内存满了,无法存放新对象,使得方法抛出内存溢出的异常。 方法由于异常而出栈,方法中的对象也就失去引用,对象被回收,堆内存回复正常,其他...
  • Java内存溢出就是你要求分配的内存超出了系统能给你的,系统不能满足需求,于是产生溢出。Java内存泄露与溢出的区别内存溢出就是你要求分配的内存超出了系统能给你的,系统不能满足需求,于是产生溢出。Java内存...
  • Java 堆用于存储对象实例,只要不断地创建对象,并且保证垃圾回收机制清除这些对象,那么在对象数量达到最大堆限制就会产生内存溢出异常。 测试方案:无限循环new对象实例出来,在List中保存引用,防止GC回...
  • 说白了就是程序运行要用到的内存大于虚拟机能提供的最大内存就发生内存溢出了。 内存溢出的问题要看业务和系原因有很多种,比如:1。数据量过于庞大;死循环 ;静态变量和静态方法过多;递归;无法确定是否被引用的...
  • 内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory; 内存泄露 memory leak,是指程序在申请内存后,无法释放已申请的内存空间,一次内存泄露危害可以忽略,但内存...
  • Java内存溢出泄漏的排查

    千次阅读 2019-06-19 10:04:53
    一定是有一个项目在跑着,然后突然变慢了,你才会想到排查内存泄露的问题的。作为小白,写写逻辑,我觉得基本上接触不到这个问题。自己写程序报错OOM,那需要很大的代码错误。 我接触到这个问题是上次项目经理面试...
  • 一、内存溢出 内存溢出 (out of memory),是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory; 内存溢出的原因及解决方法: (1) 内存溢出原因: 内存中加载的数据量过于庞大,如一次从...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,980
精华内容 18,792
关键字:

java内存溢出与泄露

java 订阅