深入理解JVM-内存溢出案例演示与分析

1.java堆溢出

　　

　　思路：Java堆用于存储对象实例，只要不断地创建对象，并且保证GC Roots到对象之间有可达路径来避免垃圾回收机制清除这些对象，

　　　　　那么在对象数量到达最大堆的容量限制后就会产生内存溢出异常。

　    jvm参数：-Xmx 20M, -Xms 20M,避免堆自动扩展。

　　案列代码：

　　https://www.cnblogs.com/newAndHui/p/11105956.html 的2.4.案例四:内存快照分析
　　运行结果：Java heap space
　　解决方案：
　　1.先通过内存映像分析工具（如Eclipse Memory Analyzer）对Dump出来的堆转储快照进行分析
　　2.确认内存中的对象是否是必要的，也就是要先分清除到底是出现了内存泄漏（Memory Leak）还是内存溢出（Memory Overflow）
　　内存泄漏：
　　1.如果是内存泄漏，可进一步通过工具查看泄漏对象到GC Roots的引用链。
　　2.于是就能找到泄露对象是通过怎样的路径与GC Roots相关联并导致垃圾收集器无法自动回收他们的

　　内存溢出：
　　说明：如果不存在泄漏，换句话说，就是内存中的对象确实还必须存活着，
　　1.从代码上检查虚拟机的堆参数（-Xmx与-Xms），与机器物理内存对比看是否还可以调大
　　2.从代码上检查是否存在某些对象生命周期过长、持有状态时间过长的情况，尝试减少的程序运行期的内存消耗。

2.虚拟机栈和本地方法栈溢出

　　

　　.由于在HotSpot虚拟机中并不区分虚拟机栈和本地方法栈，
　　.因此，对于HotSpot来说，虽然-Xoss参数（设置本地方法栈大小）存在，但实际上是无效的，
　　.栈容量只由-Xss参数设定。
　　.关于虚拟机栈和本地方法栈，在Java虚拟机规范中描述了两种异常：

　　4.1如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常。

　　4.2如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常。

　　.这里把异常分成两种情况，看似更加严谨，但却存在着一些互相重叠的地方：
　　当栈空间无法继续分配时，到底是内存太小，还是已使用的栈空间太大，
　　其本质上只是对同一件事情的两种描述而已。

　　类比：一个袋子里面装苹果，当袋子里面无法在装苹果时，到底是袋子太小，还是苹果太大；

　　　　   装的个数代表栈的深度，苹果大小代表局部变量表的大小

　　.在实验中，将实验范围限制于单线程中的操作，

　　尝试了下面两种方法均无法让虚拟机产生OutOfMemoryError异常，

　　尝试的结果都是获得StackOverflowError异常

　　6.1.使用-Xss参数减少栈内存容量。结果：抛出StackOverflowError异常，异常出现时输出的堆栈深度相应缩小。

　　代码：

 package com.wfd360.demo01;

 /**
  * @Copyright (C)
  * @Author: LI DONG PING
  * @Date: 2019-07-15 17:17
  * @Description: 栈内存溢出测试
  * <p>
  * 测试代码设计思路
  * 修改默认堆栈大小后,利用递归调用一个方法,达到栈深度过大的异常目的,同时在递归调用过程中记录调用此次,得出最大深度的数据
  * jvm参数
  * -Xss 180k:设置每个线程的堆栈大小(最小180k),默认是1M
  */
 public class TestStackOverflowErrorDemo {
     //栈深度统计值
     private int stackLength = 1;

     /**
      * 递归方法,导致栈深度过大异常
      */
     public void stackLeak() {
         stackLength++;
         stackLeak();
     }

     /**
      * 启动方法
      * 测试结果:当-Xss 180k为180k时,stackLength~=1544,随着-Xss参数变大时stackLength值随之变大
      * @param args
      */
     public static void main(String[] args) {
         TestStackOverflowErrorDemo demo = new TestStackOverflowErrorDemo();
         try {
             demo.stackLeak();
         } catch (Throwable e) {
             System.out.println("当前栈深度:stackLength=" + demo.stackLength);
             e.printStackTrace();
         }
     }
 }

　　6.2.定义了大量的本地变量，增大此方法帧中本地变量表的长度。结果：抛出StackOverflowError异常时输出的堆栈深度相应缩小。

　　代码：

　　

　　.多线程操作：通过不断地建立线程的方式倒是可以产生内存溢出异常。
　　但是这样产生的内存溢出异常与栈空间是否足够大并不存在任何联系，
　　或者准确地说，在这种情况下，为每个线程的栈分配的内存越大，反而越容易产生内存溢出异常
　　代码：

 package com.wfd360.demo01;
 /**
  * @Copyright (C)
  * @Author: 姿势帝
  * @Date: 2019-07-15 17:17
  * @Description: 栈内存溢出测试
  * <p>
  * 测试代码设计思路
  * 通过不断地建立线程的方式倒是可以产生内存溢出异常
  * jvm参数
  * -Xss 180k:设置每个线程的堆栈大小(最小180k),默认是1M
  * 特别注意：
  * 特别提示一下，如果读者要尝试运行上面这段代码，记得要先保存当前的工作。
  * 由于在Windows平台的虚拟机中，Java的线程是映射到操作系统的内核线程上的，
  * 因此上述代码执行时有较大的风险，可能会导致操作系统假死。
  * </p>
  */
 public class JavaVMStackOOM {
     //统计线程数
     private static int threadNum;
     //让线程不停止
     private void dontStop() {
         while (true) {
         }
     }
     //不停的开启线下，指导抛出异常
     public void stackLeakByThread() {
         while (true) {
             Thread thread = new Thread(new Runnable() {
                 @Override
                 public void run() {
                     dontStop();
                 }
             });
             threadNum++;
             thread.start();
         }
     }

     /**
      * 测试方法入口
      * @param args
      */
     public static void main(String[] args)  {
         try {
             JavaVMStackOOM oom = new JavaVMStackOOM();
             oom.stackLeakByThread();
         }catch (Throwable e){
             System.out.println("当前栈深度:stackLength=" + JavaVMStackOOM.threadNum);
             e.printStackTrace();
         }
     }
 }

　　.原因：总的内存是固定的，每一个线程的内存越大，线程数就越少

　　其实原因不难理解，操作系统分配给每个进程的内存是有限制的，譬如32位的Windows限制为2GB。虚拟机提供了参数来控制Java堆和方法区的这两部分内存的最大值。

　　剩余的内存为2GB（操作系统限制）减去Xmx（最大堆容量），再减去MaxPermSize（最大方法区容量），程序计数器消耗内存很小，可以忽略掉。

　　如果虚拟机进程本身耗费的内存不计算在内，剩下的内存就由虚拟机栈和本地方法栈“瓜分”了。

　　每个线程分配到的栈容量越大，可以建立的线程数量自然就越少，建立线程时就越容易把剩下的内存耗尽。

3.方法区和运行时常量池异常

　　主要存放：字面量

　　1.String.intern()这个本地方法的作用，public native String intern();
　　1.1.如果字符串常量池中已经包含一个此String对象的字符串，则返回代表池中这个字符串的String对象，
　　1.2.否则，将此String对象包含的字符串（字面量）添加到常量池中，并且返回此String对象的引用。

　　2.jdk1.6及以前：因常量池分配在永久代（方法区）中，
　　因此我们可通过-XX: PermSize 和 -XX:MaxPermSize限制方法区大小，从而间接限制其中常量池的容量
　　测试代码：

package com.wfd360.demo01;

import java.util.ArrayList;
import java.util.List;

/**
 * 运行时常量池溢出
 * -XX:PermSize=1m -XX:MaxPermSize=2m
 * <p>
 * -XX:PermSize
 * 　　持久代（方法区）的初始内存大小。（例如：-XX:PermSize=64m）
 * -XX:MaxPermSize
 * 　　持久代（方法区）的最大内存大小。（例如：-XX:MaxPermSize=512m）
 */
public class RuntimeConstantPoolOOM {
     private static  int i=0;
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        //使用list来保持常量池引用，避免发生full GC的操作：
        int i = 0;
        while (true) {
            String str="我是字面量-"+i;
            //其中intern（）是一个native的方法，而且是一个外部引用的方法：
            //作用：
            //1.1.如果字符串常量池中已经包含一个此String对象的字符串，则返回代表池中这个字符串的String对象，
            //1.2.否则，将此String对象包含的字符串（字面量）添加到常量池中，并且返回此String对象的引用。
            list.add(str.intern());
        }
    }
}

　　3.深入理解运行时常量池、字符串相加、变量相加、常量池中的默认值

 package com.wfd360.test2;

 import org.junit.Test;

 public class Test2Demo {
     /**
      * 知识点
      * intern()：方法的作用
      * 1.如果字符串常量池中已经包含一个此String对象的字符串，则返回代表池中这个字符串的String对象，
      * 2.否则，将此String对象包含的字符串（字面量）添加到常量池中，并且返回此String对象的引用。
      */
     @Test
     public void test7() {
         //1.直接放入运行时常量池，并且不重复
         String str1 = "姿势帝";
         //2.隐藏步骤："姿势帝"，放入常量池，如果没有的话，然后在在堆中创建对象，返回堆中的引用
         String str2 = new String("姿势帝");
         //3.字符串相加：常量池中将出现："姿"  "势帝" "姿势帝"，但是不会重复，最终返回："姿势帝" 的引用
         String str3 = "姿" + "势帝";
         //4.变量参与相加：会在堆中创建对象，并返回堆中的引用
         // param + "势帝" 的过程是创建了一个StringBuffer对象，然后用StringBuffer对象执行append方法追加，
         // 最后再转成String类型，也就是str4是放在heap里面的对象，
         String param1 = "姿";
         String str4 = param1 + "势帝";
         //5.运行时常量池中只有“姿势2” “帝2”，堆中返回“姿势帝”的引用
         String param2 = new StringBuffer("姿势2").append("帝2").toString();
         //虽然常量池中没有“姿势帝”，但堆中有“姿势帝”的引用，所以：常量池直接返回堆中的引用
         String str5 = param2.intern();
         //6.对比第5点，先放入常量池，在调用intern()方法
         String param3 = new StringBuffer("姿势3").append("帝3").toString();
         String param4 = "姿势帝3";
         //虽然堆中有“姿势帝3”，但是常量池中也有，所以调用param3.intern()方法时，直接返回param4地址的引用
         String str6 = param3.intern();
     }

     /**
      * 实战案例：
      * 1.String 和 new String()的区别
      */
     @Test
     public void test6() {
         // String 和 new String()的区别
         //案例
         String str1 = "姿势帝";
         String str2 = new String("姿势帝");

         //String str1 = "姿势帝";
         // 可能创建一个对象或者不创建对象。
         //如果 "姿势帝" 这个字符串在java String运行时常量池异常中不存在，会在java String池中创建一个String str1 = "姿势帝" 的对象。然后把str1指向这个内存地址。之后用这种方式创建多少个值为 "姿势帝"
         // 的字符串对象。始终只有一个内存地址被分配，之后都是String的copy。这种被称为‘字符串驻留’，所有的字符串都会在编译之后自动驻留。

         //String str2 = new String("姿势帝");
         // 至少会创建一个对象，也可能2个。
         // 因为用到了new的关键字，肯定会在heap中创建一个str2的对象。它的value值是 "姿势帝"，同时如果这个字符串在string池中不存在，会在string词中创建这个string对象 "姿势帝"。
     }

     /**
      * 实战案例
      * 2.理解字符串拼接与变量拼接的区别
      */
     @Test
     public void test5() {
         String str1 = new String("姿势帝");
         String str2 = new String("姿势帝");
         System.out.println(str1.equals(str2)); // true 比较的值
         System.out.println(str1 == str2); // false 比较的是内存地址。

         String str3 = "姿势帝";
         String str4 = "姿势帝";
         String str5 = "姿势" + "帝";//字符串拼接不会在堆中创建对象
         System.out.println(str3 == str4); //true 在string池中都是一个内存地址被分配给str3,str4,str5
         System.out.println(str3 == str5); //true

         String str6 = "姿势";
         String str7 = str6 + "帝";//变量拼接会在堆中创建对象，返回堆中的引用
         System.out.println(str3 == str7); //false
         System.out.println(str3 == str7.intern()); //true

         //str6在编译的时候已经确认为string池的对象。
         //str7在编译的时候不能确认，故str7是一个引用变量。
         //str6 + "帝" 的过程是创建了一个StringBuffer对象，然后用StringBuffer对象执行append方法追加，最后再转成String类型，也就是str7是放在heap里面的对象，
         //str6是放在String常量池里的。两个的内存地址不一样。故结果为false。
     }

     /**
      * 实战案例
      * 3.理解堆与常量池的引用
      */
     @Test
     public void test4() {
         String str7 = new String("姿势帝");
         System.out.println(str7 == str7.intern()); //false
     }

     /**
      * 实战案例
      * 4.理解堆与常量池的引用
      */
     @Test
     public void test3() {
         //姿势帝:先将这个放入常量池，再在堆中创建对象
         String str7 = new StringBuffer("姿势帝").toString();
         System.out.println(str7 == str7.intern()); //false
     }

     /**
      * 实战案例
      * 5.理解堆与常量池的引用
      */
     @Test
     public void test2() {
         //str7 是堆里面的对象，同时
         String str7 = new StringBuffer("姿势").append("帝").toString();
         String intern7 = str7.intern();
         String str8 = "姿势帝";
         System.out.println(str7 == intern7); //true
         System.out.println(str7 == str8); //true
         System.out.println(intern7 == str8); //true
     }
     /**
      * 实战案例
      * 6.常量池中的默认字符串，如java
      */
     @Test
     public void test() {
         //str7 是堆里面的对象，同时
         String str7 = new StringBuffer("ja").append("va").toString();
         String intern7 = str7.intern();
         String str8 = "java";
         System.out.println(str7 == intern7); //false
         System.out.println(str7 == str8); //false
         System.out.println(intern7 == str8); //true
     }
 }