《深入理解Java虚拟机》读书笔记一

第二章 Java内存区域与内存溢出异常

1、运行时数据区域

程序计数器：

• 当前线程所执行的字节码的行号指示器，用于存放下一条需要运行的指令。
• 运行速度最快位于处理器内部。
• 线程私有。

虚拟机栈：

• 描述的是Java方法执行的内存模型，用于存放对象的引用和基本数据类型。
• 每个方法执行的时候都会创建一个栈帧（stack frame）用于存放 局部变量表、操作栈、动态链接、方法出口。
• 线程私有，生命周期与线程相同。

方法栈：

• 和虚拟机栈功能类似，管理本地的方法调用。
• 虚拟机栈为虚拟机执行的Java方法的方法服务，方法栈则为虚拟机使用的本地方法的服务。

堆：

• 虚拟机最大的一块区域，虚拟机启动的时候创建。
• 用于存放对象的实例，所有对象实例和数据的在堆上分配内存。
• 线程共享的区域。

方法区：

• 用于存放一些类信息，常量，静态变量和即时编译后的代码等数据。
• 线程共享的区域。

运行时常量池：

• 方法区的一部分，用于存放编译期生成的各种字面量和符号引用。

直接内存：

• 不属于运行时数据区，堆外内存。

2、HotSpot虚拟机对象探秘

对象的创建：

• 接受new关键字指令后，检查指令参数是否能在常量池中定位到一个类的符号引用
• 然后检查符号引用对应的类是否已被加载、解析和初始化。如果没有就执行。
• 类加载通过后，虚拟机为新生的对象分配内存。
• 内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值。
• 虚拟机设置对象头信息。

内存分配的方式：

• 指正碰撞，内存是规整的，所有用过的内存放在一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器。
• 空闲列表，内存不规整，虚拟机维护一个列表用来记录那些内存是可用的，分配时从中找到足够的内存划分给对象，并更新表记录。

保证线程安全的方式：

• CAS，对分配的内存空间进行同步处理，采用CAS配上失败重试的方式保证操作的原子性。
• 线程分配缓冲区，把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在Java堆中预先分配好内存。

对象的内存布局：

• 对象在内存中存储的布局可以分为三块区域对象头、实例数据和对齐填充。
• 对象头，又可以分为两部分，第一部分存储自身运行时数据，第二部分是类型指针
• 自身运行数据主要包括哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳。
• 类型指针即对象指向他的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。
• 实例数据，对象真正存储的有用的有效信息，继承父类的字段也会包含。
• 对齐填充，对象起始地址必须是8的整数倍，对齐填充起到了占位符的作用。

对象的访问定位：

• 使用句柄的访问方式，堆中将划分出来一块内存作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址。reference中存储的是稳定的句柄地址，如果对象被移动，reference的地址无需改变。
• 使用直接指针访问，reference中存储的直接就是对象的地址。直接指针访问可以减少指针定位的时间开销。

3、OOM异常

• Java堆溢出，Java堆用于存储对象实例，只要不断的创建对象，并且保证GC Root到对象之间有可达路径来避免垃圾回收，那么对象数量到达最大堆的容量限制后就会产生内存溢出异常。

  package com.ecut.exception;
   
  import java.util.ArrayList;
  import java.util.List;
   
  /**
   * -Xms20m -Xmx20m  -XX:+HeapDumpOnOutOfMemoryError
   */
  public class HeapOOM {
   
      static class OOMObject{
   
      }
      public static void main(String[] args) {
          List<OOMObject> list = new ArrayList<>();
          while (true){
              list.add(new OOMObject());
          }
      }
  }

  运行结果如下：

  java.lang.OutOfMemoryError: Java heap space
  Dumping heap to java_pid6776.hprof ...
  Heap dump file created [28247587 bytes in 0.149 secs]
  Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
      at java.util.Arrays.copyOf(Arrays.java:3210)
      at java.util.Arrays.copyOf(Arrays.java:3181)
      at java.util.ArrayList.grow(ArrayList.java:261)
      at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:235)
      at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:227)
      at java.util.ArrayList.add(ArrayList.java:458)
      at com.ecut.exception.HeapOOM.main(HeapOOM.java:17)

• 虚拟机栈和本地方法栈溢出，如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常，如果虚拟机在拓展栈时无法申请到足够的内存空间则抛出OutOfMemoryError异常。

  package com.ecut.exception;
   
  /**
   * -Xss128k
   */
  public class JavaVMStackSOF {
   
      private int stackLength = 1;
   
      public void stackLeak(){
          stackLength++;
          stackLeak();
      }
   
      public static void main(String[] args) {
          JavaVMStackSOF javaVMStackSOF = new JavaVMStackSOF();
          try {
              javaVMStackSOF.stackLeak();
          }catch (Exception e){
              System.out.println("stack length :" + javaVMStackSOF.stackLength);
              throw e;
   
          }
      }
  }

  运行结果如下：

  Exception in thread "main" java.lang.StackOverflowError
      at com.ecut.exception.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:12)

  创建线程导致内存溢出异常：

  package com.ecut.exception;
   
  /**
   * -Xss2M
   */
  public class JavaVMStackOOM {
   
      private  void dontStop(){
          while(true){
   
          }
      }
   
      public void stackLeakByThread(){
          while (true){
              Thread thread = new Thread(new Runnable() {
                  @Override
                  public void run() {
                      dontStop();
                  }
              });
              thread.start();
          }
      }
   
      public static void main(String[] args) {
          JavaVMStackOOM javaVMStackOOM = new JavaVMStackOOM();
          javaVMStackOOM.stackLeakByThread();
      }
  }

• 方法区和运行时常量池溢出

  package com.ecut.exception;
   
  import java.util.ArrayList;
  import java.util.List;
   
  /**
   * -XX:PermSize=10M -XX:MaxPermSize=10M  JDK 1.6 会抛出OOM异常，JDK1.7开始了去永久代
   */
  public class RuntimeConstantPoolOOM {
      public static void main(String[] args) {
          //使用list保持着产量池的引用，避免fullGC回收常量池的行为
          List<String> list  = new ArrayList<>();
          int i = 0 ;
          while(true){
              list.add(String.valueOf(i++));
          }
      }
  }

  String.intern()方法如果字符串常量池中已经包含了一个等于String对象的字符串，则返回代表池中这个字符串的String对象。否则将此对象包含的字符串添加到常量池中。

  package com.ecut.exception;
   
  public class RuntimeConstantPool {
      public static void main(String[] args) {
          /*jdk1.6 intern方法会把首次遇到的字符串实例复制到永久代中，返回的也是这个永久代中的这个字符串实例的引用。
          StringBuilder创建的字符串实例在Java堆上，所以必然不是同一个引用
          jdk1.7中intern实现只是在常量池中记录首次出现的实例引用，因此intern返回的引用和StringBuilder创建的那个字符
          串实例时同一个*/
          String s1 = new StringBuilder("计算机").append("软件").toString();
          System.out.println(s1.intern() == s1);
      }
  }

  运行结果：

  true

• 本机直接内存溢出

  package com.ecut.exception;
   
  import sun.misc.Unsafe;
   
  import java.lang.reflect.Field;
   
  /**
   *  -Xmx20M -XX:MaxDirectMemorySize = 10M
   */
  public class DirectMemoryOOM {
      private  static final int _1MB = 1024*1024;
   
      public static void main(String[] args) throws IllegalAccessException {
          Field unsafeField = Unsafe.class.getDeclaredFields()[0];
          unsafeField.setAccessible(true);
          Unsafe unsafe = (Unsafe) unsafeField.get(null);
          while (true){
              unsafe.allocateMemory(_1MB);
          }
      }
  }

  运行结果如下：

  Exception in thread "main" java.lang.OutOfMemoryError
      at sun.misc.Unsafe.allocateMemory(Native Method)
      at com.ecut.exception.DirectMemoryOOM.main(DirectMemoryOOM.java:18)

源码地址：

https://github.com/SaberZheng/jvm-test

转载请于明显处标明出处:

https://www.cnblogs.com/AmyZheng/p/10504443.html