java入门之java虚拟机之运行时数据区（1）

什么是java虚拟机

JVM(虚拟机)：指以软件的方式模拟具有完整硬件系统功能、运行在一个完全隔离环境中的完整计算机系统 ，是物理机的软件实现。常用的虚拟机有VMWare，Virtual Box，Java Virtual Machine
Java虚拟机阵营：Sun HotSpot VM、BEA JRockit VM、IBM J9 VM、Azul VM、Apache Harmony、Google Dalvik VM、Microsoft JVM...

JVM整体架构

jvm有三部分主要的子系统构成

1. 类加载子系统
2. 运行时数据区
3. 执行引擎

整体的架构如图所示：

这个图，每个人应该都非常地清楚，当初面试的时候都背过。如果这样讲的话，也没有任何意义。按照理解的层次，应该是从一个线程入手，先把基本的定义贴出来，读上一遍。

1. 本地方法栈(线程私有)：登记native方法，在Execution Engine执行时加载本地方法库。
2. 程序计数器（线程私有）：就是一个指针，指向方法区中的方法字节码（用来存储指向下一条指令的地址,也即将要执行的指令代码），由执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不记。
3. 方法区(线程共享)：类的所有字段和方法字节码，以及一些特殊方法如构造函数，接口代码也在此定义。简单说，所有定义的方法的信息都保存在该区域，静态变量+常量+类信息(构造方法/接口定义)+运行时常量池都存在方法区中，虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做 Non-Heap（非堆），目的应该是与 Java 堆区分开来。
4. Java栈（线程私有）： Java线程执行方法的内存模型，一个线程对应一个栈，每个方法在执行的同时都会创建一个栈帧（用于存储局部变量表，操作数栈，动态链接，方法出口等信息）不存在垃圾回收问题，只要线程一结束该栈就释放，生命周期和线程一致。
   下图是栈帧的详细图解：

这样就有了一个大概的了解，堆和方法区（java8 元空间）是线程共享的，栈、本地方法栈、程序计数器是线程私有的，也就是说每一个线程都是有这三部分组成的。下面通过一个线程，深入地了解其中的存放过程。
源码如下：

public class Math {
    public static final Integer CONSTANT = 666;

    public int math(){
        int a = 1;
        int b = 2;
        int c = (a+b)*10;
        return c;
    }

    public static void main(String[] args){
        Math m = new Math();
        m.math();
        System.out.println("end");
    }

这是一个非常简单的求和线程。当我们执行main方法就会将该线程启动起来，运行其结果。但是从这里也看不来如何在虚拟机中运转，下面将其反编译成汇编语言，去看它在虚拟机中走的每一步。
先javac -g Math.java 编译成class文件。然后对Math类进行反汇编：$ javap -c -l Math 结果如下：

public class Math {
  public static final java.lang.Integer CONSTANT;

  public Math();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
    LineNumberTable:
      line 1: 0
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0       5     0  this   LMath;

  public int math();
    Code:
       0: iconst_1          //将int类型常量1压入栈(也就是把 1 放入到操作数栈中)
       1: istore_1           //将int类型值存入局部变量1（也就是把 1 取出栈 然后放入到局部变量表，给a）
       2: iconst_2           //将int类型常量2压入栈（也就是把 2 放入到操作数栈中）
       3: istore_2			//将int类型值存入局部变量2（也就是把栈顶 2 取出栈，然后放入到局部变量表，给b）
       4: iload_1				//从局部变量1中装载int类型值（也就是从局部变量表中复制取出 1 ，放入到操作数栈）
       5: iload_2				//从局部变量2中装载int类型值（也就是从局部变量表中复制取出 2 ，放入到操作数栈）
       6: iadd					//执行int类型的加法 （从栈顶弹出两个数值，因为是先进后出，所以先取出是2 再取出1 相加得到3 把 3这个结果再放入到操作数栈中）
       7: bipush        10	//常数到操作数栈（把 常量10 进行入栈）
       9: imul					// 进行乘法计算 （从栈顶弹出两个数值，因为是先进后出，所以先取出是10 再取出3 相乘得到30 把 30这个结果再放入到操作数栈中）
      10: istore_3			//将int类型值存入局部变量3（也就是把 30 取出栈 然后放入到局部变量表，给c）
      11: iload_3				//从局部变量3中装载int类型值（也就是从局部变量表中复制取出 30 ，放入到操作数栈）
      12: ireturn				//从方法中返回int类型的数据
    LineNumberTable:
      line 6: 0
      line 7: 2
      line 8: 4
      line 9: 11
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0      13     0  this   LMath;
          2      11     1     a   I
          4       9     2     b   I
         11       2     3     c   I

  public static void main(java.lang.String[]);
    Code:
    // new指令，创建一个class Math对象，new指令并不能完全创建一个对象，对象只有在调用初始化方法完成后（也就是调用了invokespecial指令之后），对象才创建成功。
       0: new           #2                  // 创建对象，并将对象引用压入栈
       3: dup								//将操作数栈的数据复制一份，并压入栈，此时栈中有两个引用值
       4: invokespecial #3                  // Method "<init>":()V  pop出栈引用值,调用其构造函数，完成对象的初始化
       7: astore_1								//pop出栈引用值，将其（引用）赋值给局部变量表中的变量m
       8: aload_1								//将m的引用值压入栈，因为m.math();调用了m，这里使用aload_1从局部变量表中获得对应的变量m的值并压入操作数栈
       9: invokevirtual #4                  // Method math:()I  引用出栈，调用m的math()方法
      12: pop									// 弹出栈顶端一个字长的内容
      13: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      16: ldc           #6                  // String end
      18: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      21: return
    LineNumberTable:
      line 13: 0
      line 14: 8
      line 15: 13
      line 16: 21
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0      22     0  args   [Ljava/lang/String;
          8      14     1     m   LMath;

  static {};
    Code:
       0: sipush        666
       3: invokestatic  #8                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       6: putstatic     #9                  // Field CONSTANT:Ljava/lang/Integer;
       9: return
    LineNumberTable:
      line 3: 0
}

这个时候，可以参考我之前的jvm指令手册来读这段汇编。基本的汇编对应的jvm操作我都做了注释。最终的运行结果如截图所示：

栈+堆+方法区的交互关系

HotSpot是使用指针的方式来访问对象
Java堆中会存放访问类元数据的地址
reference存储的就直接是对象的地址

栈的内容基本结束，下面主要是介绍堆的内容：

堆(线程共享)：虚拟机启动时创建，用于存放对象实例，几乎所有的对象（包含常量池）都在堆上分配内存，当对象无法再该空间申请到内存时将抛出OutOfMemoryError异常。同时也是垃圾收集器管理的主要区域。可通过 -Xmx –Xms 参数来分别指定最大堆和最小堆

新生区

类诞生、成长、消亡的区域，一个类在这里产生，应用，最后被垃圾回收器收集，结束生命。
新生区分为两部分： 伊甸区（Eden space）和幸存者区（Survivor pace） ，所有的类都是在伊甸区被new出来的。幸存区有两个： 0区（Survivor 0 space）和1区（Survivor 1 space）。当伊甸园的空间用完时，程序又需要创建对象，JVM的垃圾回收器将对伊甸园区进行垃圾回收(Minor GC)，将伊甸园区中的不再被其他对象所引用的对象进行销毁。然后将伊甸园中的剩余对象移动到幸存 0区。若幸存 0区也满了，再对该区进行垃圾回收，然后移动到1区。那如果1区也满了呢？

老年区

新生区经过多次GC仍然存活的对象移动到老年区。若老年区也满了，那么这个时候将产生MajorGC（FullGC），进行老年区的内存清理。若老年区执行了Full GC之后发现依然无法进行对象的保存，就会产生OOM异常“OutOfMemoryError”

元数据区

元数据区：元数据区取代了永久代(jdk1.8以前)，本质和永久代类似，都是对JVM规范中方法区的实现，区别在于元数据区并不在虚拟机中，而是使用本地物理内存，永久代在虚拟机中，永久代逻辑结构上属于堆，但是物理上不属于堆，堆大小=新生代+老年代。元数据区也有可能发生OutOfMemory异常。
Jdk1.6及之前： 有永久代, 常量池在方法区
Jdk1.7： 有永久代，但已经逐步“去永久代”，常量池在堆
Jdk1.8及之后： 无永久代，常量池在元空间
元数据区的动态扩展，默认–XX:MetaspaceSize值为21MB的高水位线。一旦触及则Full GC将被触发并卸载没有用的类（类对应的类加载器不再存活），然后高水位线将会重置。新的高水位线的值取决于GC后释放的元空间。如果释放的空间少，这个高水位线则上升。如果释放空间过多，则高水位线下降。
为什么jdk1.8用元数据区取代了永久代？
官方解释：移除永久代是为融合HotSpot JVM与 JRockit VM而做出的努力，因为JRockit没有永久代，不需要配置永久代。