• 内存溢出常见问题

    Java虚拟机规范规定JVM的内存分为了好几块，比如堆，栈，程序计数器，方法区等，而Hotspot jvm的实现中，将堆内存分为了三部分，新生代，老年代，持久带，其中持久带实现了规范中规定的方法区，而内存模型中不同的部分都会出现相应的OutOfMemoryError错误，接下来我们就分开来讨论一下。java.lang.OutOfMemoryError这个错误我相信大部分开发人员都有遇到过，产生该错误的原因大都出于以下原因：

    JVM内存过小、程序不严密，产生了过多的垃圾。

    导致OutOfMemoryError异常的常见原因有以下几种：

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

    此错误常见的错误提示：

    • tomcat:java.lang.OutOfMemoryError: PermGen space
    • tomcat:java.lang.OutOfMemoryError: Java heap space
    • weblogic:Root cause of ServletException java.lang.OutOfMemoryError
    • resin:java.lang.OutOfMemoryError
    • java:java.lang.OutOfMemoryError

    栈溢出(StackOverflowError)

    栈溢出抛出java.lang.StackOverflowError错误，出现此种情况是因为方法运行的时候栈的深度超过了虚拟机容许的最大深度所致。出现这种情况，一般情况下是程序错误所致的，比如写了一个死递归，就有可能造成此种情况。 下面我们通过一段代码来模拟一下此种情况的内存溢出。

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    import java.util.*;

    import java.lang.*;

    public class OOMTest{

       

     public void stackOverFlowMethod(){

       stackOverFlowMethod();

     }

       

     public static void main(String... args){

       OOMTest oom = new OOMTest();

       oom.stackOverFlowMethod();

     }

    }

    运行上面的代码，会抛出如下的异常：

    ?

    1

    2

    Exception in thread "main" java.lang.StackOverflowError

        at OOMTest.stackOverFlowMethod(OOMTest.java:6)

    堆溢出(OutOfMemoryError:java heap space)

    堆内存溢出的时候，虚拟机会抛出java.lang.OutOfMemoryError:Java heap space,出现此种情况的时候，我们需要根据内存溢出的时候产生的dump文件来具体分析（需要增加-XX:+HeapDumpOnOutOfMemoryErrorjvm启动参数）。出现此种问题的时候有可能是内存泄露，也有可能是内存溢出了。

    如果内存泄露，我们要找出泄露的对象是怎么被GC ROOT引用起来，然后通过引用链来具体分析泄露的原因。

    如果出现了内存溢出问题，这往往是程序本生需要的内存大于了我们给虚拟机配置的内存，这种情况下，我们可以采用调大-Xmx来解决这种问题。

    下面我们通过如下的代码来演示一下此种情况的溢出：

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    import java.util.*;

    import java.lang.*;

    public class OOMTest{

       

        public static void main(String... args){

            List<byte[]> buffer = new ArrayList<byte[]>();

            buffer.add(new byte[10*1024*1024]);

        }

       

    }

    我们通过如下的命令运行上面的代码：

    ?

    1

    java -verbose:gc -Xmn10M -Xms20M -Xmx20M -XX:+PrintGC OOMTest

    程序输入如下的信息：

    ?

    1

    2

    3

    4

    5

    [GC 1180K->366K(19456K), 0.0037311 secs]

    [Full GC 366K->330K(19456K), 0.0098740 secs]

    [Full GC 330K->292K(19456K), 0.0090244 secs]

    Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

        at OOMTest.main(OOMTest.java:7)

    从运行结果可以看出，JVM进行了一次Minor gc和两次的Major gc，从Major gc的输出可以看出，gc以后old区使用率为134K，而字节数组为10M，加起来大于了old generation的空间，所以抛出了异常，如果调整-Xms21M,-Xmx21M,那么就不会触发gc操作也不会出现异常了。

    通过上面的实验其实也从侧面验证了一个结论：当对象大于新生代剩余内存的时候，将直接放入老年代，当老年代剩余内存还是无法放下的时候，触发垃圾收集，收集后还是不能放下就会抛出内存溢出异常了

    持久带溢出(OutOfMemoryError: PermGen space)

    我们知道Hotspot jvm通过持久带实现了Java虚拟机规范中的方法区，而运行时的常量池就是保存在方法区中的，因此持久带溢出有可能是运行时常量池溢出，也有可能是方法区中保存的class对象没有被及时回收掉或者class信息占用的内存超过了我们配置。当持久带溢出的时候抛出java.lang.OutOfMemoryError: PermGen space。

    我在工作可能在如下几种场景下出现此问题。

    使用一些应用服务器的热部署的时候，我们就会遇到热部署几次以后发现内存溢出了，这种情况就是因为每次热部署的后，原来的class没有被卸载掉。

    如果应用程序本身比较大，涉及的类库比较多，但是我们分配给持久带的内存（通过-XX:PermSize和-XX:MaxPermSize来设置）比较小的时候也可能出现此种问题。

    一些第三方框架，比如spring,hibernate都通过字节码生成技术（比如CGLib）来实现一些增强的功能，这种情况可能需要更大的方法区来存储动态生成的Class文件。

    我们知道Java中字符串常量是放在常量池中的，String.intern()这个方法运行的时候，会检查常量池中是否存和本字符串相等的对象，如果存在直接返回对常量池中对象的引用，不存在的话，先把此字符串加入常量池，然后再返回字符串的引用。那么我们就可以通过String.intern方法来模拟一下运行时常量区的溢出.下面我们通过如下的代码来模拟此种情况：

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    import java.util.*;

    import java.lang.*;

    public class OOMTest{

       

        public static void main(String... args){

            List<String> list = new ArrayList<String>();

            while(true){

                list.add(UUID.randomUUID().toString().intern());

            }

        }

       

    }

    我们通过如下的命令运行上面代码：

    ?

    1

    java -verbose:gc -Xmn5M -Xms10M -Xmx10M -XX:MaxPermSize=1M -XX:+PrintGC OOMTest

    运行后的输入如下图所示:

    ?

    1

    2

    3

    Exception in thread "main" java.lang.OutOfMemoryError: PermGen space

        at java.lang.String.intern(Native Method)

        at OOMTest.main(OOMTest.java:8)

    通过上面的代码，我们成功模拟了运行时常量池溢出的情况，从输出中的PermGen space可以看出确实是持久带发生了溢出，这也验证了，我们前面说的Hotspot jvm通过持久带来实现方法区的说法。

    持久代内存溢出解决办法

    windows-preferences-java-Installed jres

     

     

     然后复制以下内容到相应位置，重新启动项目即可

    -Xms512m -Xmx512m -XX:MaxNewSize=512m -XX:MaxPermSize=512m

     

    OutOfMemoryError:unable to create native thread

    最后我们在来看看java.lang.OutOfMemoryError:unable to create natvie thread这种错误。 出现这种情况的时候，一般是下面两种情况导致的：

    程序创建的线程数超过了操作系统的限制。对于Linux系统，我们可以通过ulimit -u来查看此限制。

    给虚拟机分配的内存过大，导致创建线程的时候需要的native内存太少。我们都知道操作系统对每个进程的内存是有限制的，我们启动Jvm,相当于启动了一个进程，假如我们一个进程占用了4G的内存，那么通过下面的公式计算出来的剩余内存就是建立线程栈的时候可以用的内存。 线程栈总可用内存=4G-（-Xmx的值）- （-XX:MaxPermSize的值）- 程序计数器占用的内存 通过上面的公式我们可以看出，-Xmx 和 MaxPermSize的值越大，那么留给线程栈可用的空间就越小，在-Xss参数配置的栈容量不变的情况下，可以创建的线程数也就越小。因此如果是因为这种情况导致的unable to create native thread,那么要么我们增大进程所占用的总内存，或者减少-Xmx或者-Xss来达到创建更多线程的目的。

    JVM调优工具

    Jconsole : jdk自带，功能简单，但是可以在系统有一定负荷的情况下使用。对垃圾回收算法有很详细的跟踪。

    JProfiler：商业软件，需要付费。功能强大。

    VisualVM：JDK自带，功能强大，与JProfiler类似。推荐。

    如何调优

    观察内存释放情况、集合类检查、对象树

    上面这些调优工具都提供了强大的功能，但是总的来说一般分为以下几类功能

    堆信息查看

    1.  可查看堆空间大小分配（年轻代、年老代、持久代分配）
    2.  提供即时的垃圾回收功能
    3.  垃圾监控（长时间监控回收情况）

    查看堆内类、对象信息查看：数量、类型等

    对象引用情况查看

    有了堆信息查看方面的功能，我们一般可以顺利解决以下问题：

    • 年老代年轻代大小划分是否合理
    • 内存泄漏
    • 垃圾回收算法设置是否合理

    线程监控

    1.  线程信息监控：系统线程数量。
    2.  线程状态监控：各个线程都处在什么样的状态下

    1.  Dump线程详细信息：查看线程内部运行情况
    2.  死锁检查

    热点分析

    CPU热点：检查系统哪些方法占用的大量CPU时间

    内存热点：检查哪些对象在系统中数量最大（一定时间内存活对象和销毁对象一起统计）

    这两个东西对于系统优化很有帮助。我们可以根据找到的热点，有针对性的进行系统的瓶颈查找和进行系统优化，而不是漫无目的的进行所有代码的优化。

    快照
    快照是系统运行到某一时刻的一个定格。在我们进行调优的时候，不可能用眼睛去跟踪所有系统变化，依赖快照功能，我们就可以进行系统两个不同运行时刻，对象（或类、线程等）的不同，以便快速找到问题

    举例说，我要检查系统进行垃圾回收以后，是否还有该收回的对象被遗漏下来的了。那么，我可以在进行垃圾回收前后，分别进行一次堆情况的快照，然后对比两次快照的对象情况。

    内存泄漏检查

    内存泄漏是比较常见的问题，而且解决方法也比较通用，这里可以重点说一下，而线程、热点方面的问题则是具体问题具体分析了。

    内存泄漏一般可以理解为系统资源（各方面的资源，堆、栈、线程等）在错误使用的情况下，导致使用完毕的资源无法回收（或没有回收），从而导致新的资源分配请求无法完成，引起系统错误。

    内存泄漏对系统危害比较大，因为他可以直接导致系统的崩溃。

    需要区别一下，内存泄漏和系统超负荷两者是有区别的，虽然可能导致的最终结果是一样的。内存泄漏是用完的资源没有回收引起错误，而系统超负荷则是系统确实没有那么多资源可以分配了（其他的资源都在使用）。

    年老代堆空间被占满

    异常： java.lang.OutOfMemoryError: Java heap space

    说明：

    这是最典型的内存泄漏方式，简单说就是所有堆空间都被无法回收的垃圾对象占满，虚拟机无法再在分配新空间。
    如上图所示，这是非常典型的内存泄漏的垃圾回收情况图。所有峰值部分都是一次垃圾回收点，所有谷底部分表示是一次垃圾回收后剩余的内存。连接所有谷底的点，可以发现一条由底到高的线，这说明，随时间的推移，系统的堆空间被不断占满，最终会占满整个堆空间。因此可以初步认为系统内部可能有内存泄漏。（上面的图仅供示例，在实际情况下收集数据的时间需要更长，比如几个小时或者几天）

    解决：

    这种方式解决起来也比较容易，一般就是根据垃圾回收前后情况对比，同时根据对象引用情况（常见的集合对象引用）分析，基本都可以找到泄漏点。

    ArrayList   arrayList=new ArrayList();

    while(){

    　　a1=null;

    　　a1.clear();  　　//每次调用前清理一下

           a1.trimSize();

    　　GC.Collect;

    　　//以下是业务处理的语句,需要向al中添加大量的数据

    }

    持久代被占满

    异常：java.lang.OutOfMemoryError: PermGen space

    说明：

    Perm空间被占满。无法为新的class分配存储空间而引发的异常。这个异常以前是没有的，但是在Java反射大量使用的今天这个异常比较常见了。主要原因就是大量动态反射生成的类不断被加载，最终导致Perm区被占满。

    更可怕的是，不同的classLoader即便使用了相同的类，但是都会对其进行加载，相当于同一个东西，如果有N个classLoader那么他将会被加载N次。因此，某些情况下，这个问题基本视为无解。当然，存在大量classLoader和大量反射类的情况其实也不多。
    解决：

    1. -XX:MaxPermSize=16m
    2. 换用JDK。比如JRocket。

    堆栈溢出

    异常：java.lang.StackOverflowError

    说明：这个就不多说了，一般就是递归没返回，或者循环调用造成

    线程堆栈满

    异常：Fatal: Stack size too small

    说明：java中一个线程的空间大小是有限制的。JDK5.0以后这个值是1M。与这个线程相关的数据将会保存在其中。但是当线程空间满了以后，将会出现上面异常。

    解决：增加线程栈大小。-Xss2m。但这个配置无法解决根本问题，还要看代码部分是否有造成泄漏的部分。

    系统内存被占满

    异常：java.lang.OutOfMemoryError: unable to create new native thread

    说明：

    这个异常是由于操作系统没有足够的资源来产生这个线程造成的。系统创建线程时，除了要在Java堆中分配内存外，操作系统本身也需要分配资源来创建线程。因此，当线程数量大到一定程度以后，堆中或许还有空间，但是操作系统分配不出资源来了，就出现这个异常了。

    分配给Java虚拟机的内存愈多，系统剩余的资源就越少，因此，当系统内存固定时，分配给Java虚拟机的内存越多，那么，系统总共能够产生的线程也就越少，两者成反比的关系。同时，可以通过修改-Xss来减少分配给单个线程的空间，也可以增加系统总共内生产的线程数。

    解决：

    1. 重新设计系统减少线程数量。
    2. 线程数量不能减少的情况下，通过-Xss减小单个线程大小。以便能生产更多的线程。

    垃圾回收的悖论

    所谓“成也萧何败萧何”。Java的垃圾回收确实带来了很多好处，为开发带来了便利。但是在一些高性能、高并发的情况下，垃圾回收确成为了制约Java应用的瓶颈。目前JDK的垃圾回收算法，始终无法解决垃圾回收时的暂停问题，因为这个暂停严重影响了程序的相应时间，造成拥塞或堆积。这也是后续JDK增加G1算法的一个重要原因。

    当然，上面是从技术角度出发解决垃圾回收带来的问题，但是从系统设计方面我们就需要问一下了：

    1.  我们需要分配如此大的内存空间给应用吗？
    2.  我们是否能够通过有效使用内存而不是通过扩大内存的方式来设计我们的系统呢？

    我们的内存中都放了什么

    内存中需要放什么呢？个人认为，内存中需要放的是你的应用需要在不久的将来再次用到到的东西。想想看，如果你在将来不用这些东西，何必放内存呢？放文件、数据库不是更好？这些东西一般包括：

    1. 系统运行时业务相关的数据。比如web应用中的session、即时消息的session等。这些数据一般在一个用户访问周期或者一个使用过程中都需要存在。
    2. 缓存。缓存就比较多了，你所要快速访问的都可以放这里面。其实上面的业务数据也可以理解为一种缓存。
    3. 线程。

    因此，我们是不是可以这么认为，如果我们不把业务数据和缓存放在JVM中，或者把他们独立出来，那么Java应用使用时所需的内存将会大大减少，同时垃圾回收时间也会相应减少。

    我认为这是可能的。

    解决之道

    数据库、文件系统

    把所有数据都放入数据库或者文件系统，这是一种最为简单的方式。在这种方式下，Java应用的内存基本上等于处理一次峰值并发请求所需的内存。数据的获取都在每次请求时从数据库和文件系统中获取。也可以理解为，一次业务访问以后，所有对象都可以进行回收了。

    这是一种内存使用最有效的方式，但是从应用角度来说，这种方式很低效。

    内存-硬盘映射

    上面的问题是因为我们使用了文件系统带来了低效。但是如果我们不是读写硬盘，而是写内存的话效率将会提高很多。

    数据库和文件系统都是实实在在进行了持久化，但是当我们并不需要这样持久化的时候，我们可以做一些变通——把内存当硬盘使。

    内存-硬盘映射很好很强大，既用了缓存又对Java应用的内存使用又没有影响。Java应用还是Java应用，他只知道读写的还是文件，但是实际上是内存。

    这种方式兼得的Java应用与缓存两方面的好处。memcached的广泛使用也正是这一类的代表。

    同一机器部署多个JVM

    这也是一种很好的方式，可以分为纵拆和横拆。纵拆可以理解为把Java应用划分为不同模块，各个模块使用一个独立的Java进程。而横拆则是同样功能的应用部署多个JVM。

    通过部署多个JVM，可以把每个JVM的内存控制一个垃圾回收可以忍受的范围内即可。但是这相当于进行了分布式的处理，其额外带来的复杂性也是需要评估的。另外，也有支持分布式的这种JVM可以考虑，不要要钱哦：）

    程序控制的对象生命周期
    这种方式是理想当中的方式，目前的虚拟机还没有，纯属假设。即：考虑由编程方式配置哪些对象在垃圾收集过程中可以直接跳过，减少垃圾回收线程遍历标记的时间。

    这种方式相当于在编程的时候告诉虚拟机某些对象你可以在*时间后在进行收集或者由代码标识可以收集了（类似C、C++），在这之前你即便去遍历他也是没有效果的，他肯定是还在被引用的。

    这种方式如果JVM可以实现，个人认为将是一个飞跃，Java即有了垃圾回收的优势，又有了C、C++对内存的可控性。

    线程分配

    Java的阻塞式的线程模型基本上可以抛弃了，目前成熟的NIO框架也比较多了。阻塞式IO带来的问题是线程数量的线性增长，而NIO则可以转换成为常数线程。因此，对于服务端的应用而言，NIO还是唯一选择。不过，JDK7中为我们带来的AIO是否能让人眼前一亮呢？我们拭目以待。

    栈内存溢出

    http://www.voidcn.com/article/p-xxfpgyvr-bvn.html
  • 相关阅读:
    1045 access denied for user 'root'@'localhost' using password yes
    1045 access denied for user 'root'@'localhost' using password yes
    JavaWeb:EL表达式
    JavaWeb:EL表达式
    JavaWeb:EL表达式
    JavaWeb:EL表达式
    ie9支持html5 的canvas
    mysql 大于当前时间条件查询
    java 获取距离结束时间几天几小时
    java8 stream sorted
  • 原文地址：https://www.cnblogs.com/binghuaZhang/p/10780336.html
Copyright © 2020-2023  润新知