脚本宝典收集整理的这篇文章主要介绍了JVM详解（三）——运行时数据区，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。

一、概述

1、介绍

　　类比一下：红框就好比内存的运行时数据区，在各自不同的位置放了不同的东西。而厨师就好比执行引擎。

　　内存是非常重要的系统资源，是硬盘和CPU的中间仓库及桥梁，承载着操作系统和应用程序的实时运行。JVM内存布局规定了Java在运行过程中内存申请、分配、管理的策略，保证了JVM的高效稳定运行。不同的JVM对于内存的划分方式和管理机制存在着部分差异（典型的不同，就是针对方法区）。结合JVM虚拟机规范，来探讨一下经典的JVM内存布局。运行时数据区-详图：

　　红框处有变化，叫方法区，JDK7之前叫永久代，JDK8之后叫元空间。整个红框也可以叫非堆空间。具体变化在方法区一节中会详细阐述。　　Java虚拟机定义了若干个程序运行期间会使用到的运行时数据区，其中有一些会随着虚拟机启动而创建，退出而销毁；另外一些是与线程一一对应的，会随着线程开始而创建，结束而销毁。　　灰色，每个线程私有：程序计数器（PC）、虚拟机栈（VMS）、本地方法栈（NMS）。　　红色，线程共享：堆、堆外空间（方法区：永久代或叫元空间 + 代码缓存）。

　　JVM优化当中，线程里面的结构没有太多优化的点，重点说的优化（我们讲垃圾回收）指的是堆空间，当然也包括方法区（主要放类的信息）。从频率来上说，95%的垃圾回收都集中在堆区，5%是集中在方法区。方法区，jdk8以后，又叫元空间，使用的是本地内存。本地内存还是比较大的，如果没有进行过参数设置，方法区一般来说，不会出现溢出，因为本地内存一般比较大。　　每个JVM只有一个Runtime实例，即为运行时环境，相当于内存结构中间的那个框框：运行时环境。　　Runtime：运行时对象，一个JVM实例，就对应一个Runtime的实例。Runtime实例对象就相当于运行时数据区。整个运行时数据区对虚拟机来说只有一份。Runtime是单例的。

2、线程

　　线程是程序里的一个运行单元，JVM允许一个应用有多个线程并行的执行。在HotSpot JVM里，每个线程都与操作系统的本地线程直接映射。当一个Java线程准备好执行以后，此时一个操作系统的本地线程也同时创建。Java线程执行终止后，本地线程也会回收。操作系统负责所有线程的安排调度到任何一个可用的CPU上，一旦本地线程初始化成功，它就会调用Java线程中的run()方法。　　如果程序中，都是守护线程，那么虚拟机就可以退出了。　　主要的后台系统线程在HotSpot JVM里主要是一下几个：　　虚拟机线程：这种线程的操作是需要JVM达到安全点才会出现。这些操作必须在不同的线程中发生的原因是他们都需要JVM达到安全点，这样堆才不会变化。这种线程的执行类型包括"stop-the-world"的垃圾收集，线程栈收集，线程挂起以及偏向锁撤销。　　周期任务线程：这种线程是时间周期事件的体现（比如中断），他们一般用于周期性操作的调度执行。　　GC线程：这种线程对在JVM里不同种类的垃圾收集行为提供了支持。　　编译线程：这种线程在运行时会将字节码编译成到本地代码。　　信号调度线程：这种线程接收信息并发送给JVM，在它内部通过调用适当的方法进行处理。

二、程序计数器

1、介绍

　　JVM中的程序计数寄存器（PRogram Counter Register），Register的命名源于CPU的寄存器，寄存器存储指令相关的现场信息。CPU只有把数据装载到寄存器才能能够运行。这里，并非是广义上所指的物理寄存器，或许将其翻译为PC计数器（或指令计数器，也称程序钩子）会更贴切，并且不容易引起不必要的误会。JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟。　　作用：PC寄存器用来存储指向下一条指令的地址，即，将要执行的指令代码，由执行引擎读取下一条指令。

　　它是一块很小的内存空间，几乎可以忽略不计，也是运行速度最快的存储区域。在JVM规范中，每个线程都有自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致。在任何时间，一个线程都只有一个方法在执行，也就是当前方法。程序计数器会存储当前线程正在执行的Java方法的JVM指令地址。或者，如果是在执行native方法，则是未指定值（undefined）。　　它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。它是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。PC既没有GC ，也没有OOM。　　理解成游标、或者Java里集合的迭代器。用于指明当前程序到哪儿了。　　代码示例：使用说明

 1 public class Main {
 2     public static void main(String[] args) {
 3         Main test = new Main();
 4         test.minus();
 5     }
 6 
 7     public int minus() {
 8         int c = 301;
 9         int d = 401;
10         return c - d;
11         
12         // int k = c + d;
13         // String s = "abc";
14     }
15 }

　　字节码文件：

2、常见问题

　　使用PC寄存器存储字节码指令地址有什么用呢？（为什么使用PC寄存器记录当前线程的执行地址呢？）　　因为CPU需要不停的在A、B、C各个线程之间切换，切换回来以后，需要知道接着从哪开始继续执行。JVM的字节码解释器就需要通过改变PC寄存器的值来明确下一条应该执行什么样的字节码指令。

　　PC寄存器为什么会是线程私有？　　所谓的多线程，在一个特定的时间段只会执行其中某一个线程的方法，CPU不停的做切换，这样必然导致经常中断或恢复，为了能够准确的记录各个线程正在执行的当前字节码指令地址，最好的办法就是每个线程都分配一个PC寄存器，这样各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况。　　由于CPU时间片限制，众多线程在并发执行过程中，任何一个确定的时刻，一个处理器或多核处理器中的一个内核，只会执行某个线程中的一条指令。每个线程在创建后，都会产生自己的程序计数器和栈帧，程序计数器在各个线程之间互不影响。　　这个很容器理解，不各自一份的话，在切换的时候，线程1执行到哪一条指令不就丢失了嘛。

3、CPU时间片

　　CPU时间片，即CPU分配给各个程序的时间，每个线程被分配一个时间片段，称作时间片。　　在宏观上：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。　　在微观上：由于只有一个CPU，一次只能处理程序要求的一部分，通过CPU时间片轮询的方式。

三、虚拟机栈

1、介绍

　　栈和寄存器：由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。　　内存中的栈与堆：栈是运行时的单位，而堆是存储的单位。栈管运行，堆管存储。栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决数据存储的问题，即数据怎么放，放在哪儿。　　Java虚拟机栈，早期也叫Java栈，每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧，对应着一次次的Java方法调用，是线程私有的。生命周期与线程一致，一个线程，对应一个Java虚拟机栈。　　作用：主管Java程序的运行，它保存了方法的局部变量（8种基本数据类型、对象的引用地址）、部分结果、并参与方法的调用和返回。

　　主体的数据都在堆中放，对象主要在堆中放。方法内的局部变量，是放在栈空间中的。指的基本数据类型，要是引用数据类型，在栈空间，只是放了对象的引用。

　　每一个方法，跟一个栈帧都是一一对应的关系。很显然：目前方法B，是在这个栈的栈顶，把栈顶的这个方法，叫做当前方法。当方法B执行完以后，绿框就出栈了，它一出栈，方法A就变成了当前方法。一次次的方法调用，就对应着一个个栈帧的入栈出栈操作。虚拟机栈是随着线程的创建而创建的，自然也随着线程的消亡而消亡。当主线程（main方法）的methodA执行完以后，主线程就结束了，当前这个虚拟机栈就结束了。　　优点：栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器。JVM直接对Java栈的操作只有两个：每个方法执行，伴随着入栈，执行结束后，伴随着出栈。对于栈来说，不存在垃圾回收问题。

　　栈的常见异常？　　Java虚拟机规范允许Java栈的大小是动态的或者固定不变的。　　如果是固定大小的，每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定，若线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackOverflowError异常。　　如果是动态扩展的，则在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那Java虚拟机将会抛出一个OutOfMemoryError异常。　　代码示例：

1 // 方法的递归调用.栈溢出
2 public class Main {
3     public static void main(String[] args) {
4         main(args);
5     }
6 }
7 
8 // Exception in thread "main" java.lang.StackOverflowError

　　如何设置栈的大小？　　使用参数-Xss来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。　　代码示例：

 1 public class Main {
 2     private static int count = 1;
 3 
 4     public static void main(String[] args) {
 5         System.out.println(count);
 6         count++;
 7         main(args);
 8     }
 9 }
10 
11 // 未设置栈大小.默认1024k
12 // 11420
13 // Exception in thread "main" java.lang.StackOverflowError
14 
15 // 设置栈大小 -Xss256k
16 // 2463
17 // Exception in thread "main" java.lang.StackOverflowError

2、栈的存储单位（栈帧）

　　每个线程都有自己的栈，栈中的数据都是以栈帧（Stack Frame）的格式存在。在这个线程上的每个方法都各自对应一个栈帧。栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。方法和栈帧是一一对应的关系。一个方法的执行就对应一个栈帧的入栈。方法的结束，这个栈帧就会出栈。　　栈的运行原理：JVM直接对Java栈的操作只有两个，就是对栈帧的入栈和出栈。在一条活动线程中，一个时间点上，只会有一个活动的栈帧，即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧，与当前栈帧相对应的方法就是当前方法，定义这个方法的类就是当前类。　　执行引擎运行的所有字节码指令只针对当前栈帧进行操作。如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧。运行原理：

　　不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之后引用另外一个线程的栈帧。如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。Java方法有两种返回方式，一种是正常函数返回，使用return指令；另外一种是抛出异常（未捕获）。不管使用哪种方式，都会导致栈帧被弹出。　　栈的内部结构：局部变量表，操作数栈，动态链接（指向运行时常量池的方法引用），方法返回地址（或方法正常退出或者异常退出的定义），一些附加信息。

 

　　栈的大小：一个固定大小的栈，满了就会报stackoverflow，那么一个栈，到底能放多少栈帧呢？　　如果栈的大小是固定的，那么取决于栈帧的大小。栈帧小就能放的多，栈帧大就放的少。栈帧的大小主要取决于局部变量表，操作数栈。而一个栈帧的大小，又影响栈中能存放栈帧的个数。以及大概什么时候会出现异常。

3、局部变量表

　　局部变量表也称为局部变量数组或本地变量表，是一个一维的数组。定义为一个数字数组，主要用于存储方法形参和方法的局部变量，包括基本数据类型、对象引用，以及returnAddress类型。这些在编译期可知。　　由于局部变量表是建立在线程的栈上，是线程私有的，因此不存在数据安全问题。　　局部变量表所需的容量大小是在编译期就确定了，并保存在方法的code属性的maximum local VARiable数据项中，在方法运行期间是不会改变的。　　栈帧中，局部变量表的长度，所有的方法，在编译完以后，就确定了。　　方法嵌套调用的次数由栈的大小决定。局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也随之销毁。皮之不存毛将焉附。　　代码示例：局部变量表大小

 1 // 局部变量表的大小在编译期就确定
 2 public class Main {
 3     public static void main(String[] args) {
 4         Main test = new Main();
 5         int num = 10;
 6         test.methodA();
 7     }
 8 
 9     public void methodA() {
10 
11     }
12 }

　　解析字节码文件（截取部分）：

　　Start PC：0、8、11 ，变量作用域的起始位置。　　length：16，指的长度（偏移量），不是终止位置。　　StartPC + length = 16（code length）

　　slot：槽

　　参数值的存放在局部变量数组的 index0~length-1。局部变量表，最基本的存储单元是slot（变量槽）。在局部变量表里，32位以内的类型只占用一个slot，64位的类型（long、double）占用两个slot。byte、short、char、boolean在存储前被转换为int，0表示false，非0表示true。　　JVM为局部变量表每一个slot分配一个访问索引，通过这个索引访问。当一个方法被调用的时候，方法形参和方法的局部变量将按顺序被复制到每一个slot上。若需要访问一个64位的局部变量，只需要使用前一个索引即可。　　若当前栈帧是由构造方法或实例方法创建的，那么index0将会存放对象引用this，其余的参数按顺序排列。slot-槽：

　　slot的重复利用　　栈帧中的局部变量表中的槽是可以重用的。如果一个局部变量过了其作用域，那么在其后声明的新的变量就会复用过期的槽位，从而达到节省资源的目的。　　代码示例：

 1 package com.lx.jvm.day01;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5 
 6     }
 7 
 8     public void test() {
 9         int a = 100;
10         {
11             int b = 200;
12             b = a + 300;
13         }
14 
15         int c = a + 400;
16     }
17 }

　　局部变量表：

　　可以看到：变量c使用的是之前变量b销毁的slot的位置，索引为2。且变量b的作用域也不同。slot索引0 放的this。　　变量的分类

　　总结　　在栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。　　局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对用都不会被回收。

　　局部变量表中的变量，如果不存在了（这个指针不存在了）。 那这边（堆空间）的垃圾就需要被回收。这就涉及到一个性能调优的问题。　　比如：我们说栈溢出了，内存不够了。栈当中，占据空间比较大的，是局部变量表。局部变量表越大，栈帧就越大。整个栈里，能够嵌套的个数就越少。

4、操作数栈

　　操作数栈，在方法执行过程中，根据字节码指令，往栈中写入，提取数据，即入栈，出栈。某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出，使用后再把结果压栈。比如：执行复制，交换，求和等操作。　　栈：可以使用数组或链表来实现。操作数栈和局部变量表，都是用数组实现的。

　　操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量的临时存储空间。操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也随之被创建，这个方法的操作数栈是空的。每一个操作数栈都拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就确定了，保存在方法的code属性中的max_stack的值。　　栈中的元素可以是Java任意数据类型，32位占用一个栈单位，64位占用两个。操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的出栈，入栈操作来完成一次数据访问。　　如果被调用的方法带有返回值，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条执行的字节码指令。操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。因为在编译期，需要确定操作栈的大小，而不同类型需要的栈大小是不同的。　　另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。　　操作数栈是用数组实现。而我们知道，数组一旦被创建，其长度就是确定的！那么，上面提到的"这个方法的操作数栈是空的"，此时，数组被创建了，这个数组的长度是多少呢？就是下面提到的 max_stack。　　代码示例：代码追踪示例：

 1 public void test() {
 2     // byte、short、char、boolean，都是以int型来保存
 3     byte i = 15;
 4     int j = 8;
 5     int k = i + j;
 6 
 7     // int m = 800;
 8 }
 9 
10 // 对应的 bytecode
11  0 bipush 15
12  2 iStore_1
13  3 bipush 8
14  5 istore_2
15  6 iload_1
16  7 iload_2
17  8 iadd
18  9 istore_3
19 10 return

　　动态过程：

　　iadd操作（字节码指令）是从操作数栈中，弹出 8 和 15 ，由执行引擎解析为机器指令，交给CPU执行后，得出结果为23，并把执行结果压栈。

 1 // 再看一下这个的字节码指令
 2 public void test() {
 3     byte i = 15;
 4     int j = 8;
 5     int k = i + j;
 6     
 7     int m = this.test1();
 8 }
 9 
10 public int test1() {
11     return 20 + 30;
12 }

　　aload_0：获取上一个栈帧返回的结果，并保存在操作数栈中。

　　栈顶缓存技术：

　　前面介绍过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作需要使用更多的入栈，出栈指令，这同时也就意味着将需要更多的指令分派次数和内存读写次数。　　由于操作数是存储在内存中的，因此频繁的执行内存读写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读写次数，从而提升执行引擎的执行效率。寄存器，指令更少，执行速度快。

5、动态链接

　　动态链接（或指向运行时常量池的方法引用）：每一个栈帧内部包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接（Dynamic Linking），比如：invokedynamic指令。　　在字节码文件中，所有的变量和方法引用都作为符号引用保存在class文件的常量池里。动态链接的作用就是为将这些符号引用转换为调用方法的直接引用。

　　运行时常量池，就是上面的constant pool。在java.exe之后，就把constant pool，存在方法区，运行时常量池这个位置。　　为什么需要常量池？　　作用：为了提供一些符号和常量，便于指令的识别。一个在字节码文件里，一个在运行时方法区中，可以使得字节码文件比较小，不能什么都在字节码文件都写明，比如父类Object等等。

6、方法返回地址

　　存放调用该方法的PC寄存器的值。　　方法退出后，都返回到该方法被调用的位置。方法正常退出时，调用者的PC寄存器的值作为返回地址，即调用该方法的指令的下一条指令的地址。异常退出时，返回地址要通过异常表来确定，栈帧中一般不会保存这部分信息。　　当一个方法开始执行后，只有两种方式可以退出这个方法：　　正常完成出口：执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称正常完成出口。　　异常完成出口：在方法执行的过程中遇到了异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称异常完成出口。　　方法执行过程中抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码。　　本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。　　正常返回和异常返回的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。

7、一些附加信息

　　栈帧中还允许携带与Java虚拟机实现相关的一些附加信息，比如：对程序调试提供支持的信息。

四、方法的调用

1、方法的绑定机制

　　在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关。　　静态链接：当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期可知，且运行期保持不变，这种情况，将调用方法的符号引用转换为直接引用的过程称为静态链接。　　动态链接：如果被调用的目标方法在编译期不可确定，即，只能够在程序运行期将调用方法的符号引用转换为直接引用，由于这种引用转换过程具备动态性，称为动态链接。　　对应的方法的绑定机制为：早期绑定和晚期绑定。绑定是一个字段、方法或类在符号引用被替换为直接引用的过程，这仅仅发生一次。　　早期绑定：指被调用的目标方法如果在编译期可知，且运行期保持不变时，可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。　　晚期绑定：指如果被调用的方法在编译期无法确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式称为晚期绑定。　　代码示例：早期绑定和晚期绑定

 1 interface Huntable {
 2     void hunt();
 3 }
 4 
 5 class Animal {
 6     public void eat() {
 7         System.out.println("动物进食");
 8     }
 9 }
10 
11 
12 class Dog extends Animal implements Huntable {
13 
14     @override
15     public void hunt() {
16         System.out.println("狗捕耗子");
17     }
18 
19     @Override
20     public void eat() {
21         System.out.println("狗吃骨头");
22     }
23 }
24 
25 
26 class Cat extends Animal implements Huntable {
27 
28     public Cat() {
29         // 表现为：早期绑定
30         suPEr();
31     }
32 
33     public Cat(String name) {
34         // 表现为：早期绑定
35         this();
36     }
37 
38     @Override
39     public void hunt() {
40         System.out.println("猫捕耗子");
41     }
42 
43     @Override
44     public void eat() {
45         // 表现为：早期绑定
46         super.eat();
47         System.out.println("猫吃鱼");
48     }
49 }
50 
51 
52 public class Test {
53 
54     public static void main(String[] args) {
55 
56     }
57 
58     public void showAnimal(Animal animal) {
59         // 表现为：晚期绑定
60         animal.eat();
61     }
62 
63     public void showHunt(Huntable huntable) {
64         // 表现为：晚期绑定
65         huntable.hunt();
66     }
67 }

　　随着高级语言的横空出世，类似于Java一样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是它们彼此之间始终保持一个共性，那就是都支持封装，继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式。　　Java中任何一个普通的方法其实都具备虚函数的特征，它们相当于C++语言中的虚函数（C++中则需要使用关键字virtual来显示定义）。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字final来修饰。

2、虚方法与非虚方法

　　非虚方法：如果方法在编译期就确定了具体的调用版本，这个版本在运行时是不可变的，这样的方法称为非虚方法。表现为早期绑定或静态链接。静态方法、私有方法、final 方法、实例构造器、父类方法都是非虚方法。　　虚方法：其他方法称为虚方法。子类对象的多态性的使用前提：①类的继承关系，②方法的重写。

　　虚拟机中提供了以下几条方法调用指令：　　普通调用指令：

　　invokestatic：调用静态方法，解析阶段确定唯一方法版本。　　invokespecial：调用<inIT>方法、私有及父类方法，解析阶段确定唯一方法版本。　　invokevirtual：调用所有虚方法。　　invokeinterface：调用接口方法。

　　动态调用指令：

　　invokedynamic：动态解析出需要调用的方法，然后执行。

　　前四条指令固化在虚拟机内部，方法的调用执行不可人为干预，而invokedynamic指令则支持由用户确定方法版本。其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的（final修饰的除外）称为虚方法。　　代码示例：4种指令

 1 public class Main {
 2     public static void main(String[] args) {
 3         Son so = new Son();
 4         so.show();
 5     }
 6 }
 7 
 8 class Son extends Father {
 9     public Son() {
10         // invokespecial
11         super();
12     }
13 
14     public Son(int age) {
15         // invokespecial
16         this();
17     }
18 
19     // 不是重写的父类的静态方法，因为静态方法不能被重写！
20     public static void showStatic(String str) {
21         System.out.println("son " + str);
22     }
23 
24     private void showPrivate(String str) {
25         System.out.println("son private" + str);
26     }
27 
28     public void show() {
29         // invokestatic
30         showStatic("atguigu.COM");
31         // invokestatic
32         super.showStatic("good!");
33         // invokespecial
34         showPrivate("hello!");
35         // invokespecial
36         super.showCommon();
37 
38         // 因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。
39         // invokevirtual
40         showFinal();
41 
42         // 虚方法如下：
43         // invokevirtual
44         showCommon();
45         info();
46 
47         MethodInterface in = null;
48         // invokeinterface
49         in.methodA();
50     }
51 
52     public void info() {
53 
54     }
55 
56     public void display(Father f) {
57         f.showCommon();
58     }
59 
60 }
61 
62 class Father {
63     public Father() {
64         System.out.println("father的构造器");
65     }
66 
67     public static void showStatic(String str) {
68         System.out.println("father " + str);
69     }
70 
71     public final void showFinal() {
72         System.out.println("father show final");
73     }
74 
75     public void showCommon() {
76         System.out.println("father 普通方法");
77     }
78 }
79 
80 interface MethodInterface {
81     void methodA();
82 }

　　invokedynamic指令：　　JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现【动态类型语言】支持而做的一种改进。　　但是在Java7中并没有提供直接生成invokedynamic指令的方法，需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java8的Lambda表达式的出现，invokedynamic指令的生成，在Java中才有了直接的生成方式。　　Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。　　动态类型语言和静态类型语言：动态类型语言和静态类型语言的区别就在于对类型的检查是在编译期还是运行期，满足前者就是静态类型语言，反之就是动态类型语言。再直白一点就是，静态类型语言是判断变量自身的类型信息；动态类型语言是判断变量值的类型信息，变量没有类型，变量值才有类型信息，这是动态语言的一个重要特征。　　Java语言是静态类型语言。

　　Java：String info = "haha"; // info = haha;　　JS：var name = "hehe"; var name = 10;

　　代码示例：体会invokedynamic

 1 public class Main {
 2     public static void main(String[] args) {
 3         Lambda lambda = new Lambda();
 4 
 5         // invokedynamic
 6         Func func = s -> {
 7             return true;
 8         };
 9 
10         lambda.lambda(func);
11 
12         // invokedynamic
13         lambda.lambda(s -> {
14             return true;
15         });
16     }
17 }
18 
19 class Lambda {
20 
21     public void lambda(Func func) {
22         return;
23     }
24 
25 }
26 
27 @FunctionalInterface
28 interface Func {
29     public boolean func(String str);
30 }

3、方法重写的本质

　　Java语言中方法重写的本质：　　（1）找到操作数栈顶的第一个元素所执行的对象的实际类型，记作C。　　（2）如果在类型 C 中找到与常量中的描述符合简单名称都相符的方法，则进行访问权限校验。如果通过则返回这个方法的直接引用，查找过程结束；如果不通过，则返回java.lang.IllegalAccessError异常。　　（3）否则，按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。　　（4）如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。　　IllegalAccessError介绍：程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。

4、虚方法表

　　在面向对象编程中，会很频繁的使用到动态分派。如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表（virtual method table）（非虚方法不会出现在表中）来实现。使用索引表来代替查找。　　每个类中都有一个虚方法表，表中存放着各个方法的实际入口。　　那么虚方法表什么时候被创建？　　虚方法表会在类加载的链接阶段被创建并初始化，类的变量初始值准备完成之后，JVM会把该类的方法表也初始化完毕。

　　代码示例：虚方法表

 1 interface Friendly {
 2     void sayHello();
 3 
 4     void sayGoodbye();
 5 }
 6 
 7 class Cat implements Friendly {
 8     public void eat() {
 9     }
10 
11     @Override
12     public void sayHello() {
13     }
14 
15     @Override
16     public void sayGoodbye() {
17     }
18 
19     @Override
20     protected void finalize() {
21     }
22 
23     @Override
24     public String toString() {
25         return "Cat";
26     }
27 }
28 
29 class Dog {
30 
31     public void sayHello() {
32     }
33 
34     @Override
35     public String toString() {
36         return "Dog";
37     }
38 
39 }
40 
41 class CockerSpaniel extends Dog implements Friendly {
42 
43     @Override
44     public void sayHello() {
45         super.sayHello();
46     }
47 
48     @Override
49     public void sayGoodbye() {
50     }
51 }

　　Dog虚方法表：

　　CockerSpaniel虚方法表：

　　Cat虚方法表：

五、本地方法栈

1、介绍

　　Java虚拟机栈用于管理Java方法的调用，而本地方法栈用于管理本地方法的调用。本地方法栈，线程私有的。　　允许被实现成固定或者可动态扩展的内存大小（在内存溢出方面是相同的）：　　（1）如果线程请求分配的栈容量超过本地方法栈允许的最大容量，Java虚拟机将会抛出一个StackOverflowError异常。　　（2）如果本地方法栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够内存去创建对应的本地方法栈，那么Java虚拟机将会抛出一个OutOfMemoryError异常。　　本地方法是用c语言实现的。它的具体做法是Native Method Stack中登记native方法，在执行引擎执行时加载本地方法库。　　当某个线程调用一个本地方法时，它就进入了一个全新的并且不再受虚拟机限制的世界。它和虚拟机拥有同样的权限。　　（1）本地方法可以通过本地方法接口来访问虚拟机内部的运行时数据区。　　（2）它甚至可以直接使用本地处理器中的寄存器。　　（3）直接从本地内存的堆中分配任意数量的内存。　　并不是所有的JVM都支持本地方法。因为Java虚拟机规范并没有明确要求本地方法栈的使用语言、具体实现方式、数据结构等。如果JVM产品不打算支持native方法，也无需实现本地方法栈。　　在HotSpot JVM中，直接将本地方法栈和虚拟机栈合二为一了。　　代码示例：举例

 1 System.currentTimeMillis();
 2 
 3 new Thread().start();
 4 
 5 // 源码
 6 public static native long currentTimeMillis();
 7 
 8 public synchronized void start() {
 9 
10     if (threadstatus != 0)
11         throw new IllegalThreadStateException();
12     group.add(this);
13 
14     boolean started = false;
15     try {
16         start0();
17         started = true;
18     } finally {
19         try {
20             if (!started) {
21                 group.threadStartFailed(this);
22             }
23         } catch (Throwable ignore) {
24             /* do nothing. If start0 threw a Throwable then
25               it will be passed up the call stack */
26         }
27     }
28 }
29 
30 private native void start0();

六、本地方法接口

1、介绍

　　这个模块并不属于运行时数据区。简单地讲，一个Native Method就是一个Java调用非Java代码的接口。该方法的实现由非Java语言实现，比如C。这个特征并非Java所特有，很多其他的编程语言都有这一机制，比如在C++中，你可以用extern "C"告知C++编译器去调用一个C的函数。　　"A native method is a Java method whose implementation is provided by non-java code"　　在定义一个native method时，并不提供实现体（有些像定义一个Java interface），其实现体由非Java语言在外面实现。　　本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序。　　代码示例：

 1 public native void method1(int x);
 2 
 3 public native static long method2();
 4 
 5 private native synchronized float method3(Object o);
 6 
 7 native void method4(int[] x) throws Exception;
 8 
 9 // 反例，会报编译错误
10 public abstract native void method5();

　　标识符native可以与所有其他的Java标识符连用，但是abstract除外。

2、为什么要使用Native Method？

　　Java使用起来非常方便，然而有些层次的任务用Java实现起来不容易，或者对程序的效率很在意时，问题就来了。　　与Java环境外交互：有时Java应用需要与Java外面的环境交互，这是本地方法存在的主要原因。Java需要与一些底层系统，如操作系统或某些硬件交换信息时，本地方法正是这样一种交流机制，它为我们提供了一个非常简洁的接口，而且我们无需去了解Java应用之外的繁琐的细节。　　与操作系统交互：JVM支持Java语言本身和运行时库，它是Java程序赖以生存的平台，它由一个解释器（解释字节码）和一些连接到本地代码的库组成。然而不管怎样，它毕竟不是一个完整的系统，它经常依赖于一些底层系统的支持。这些底层系统常常是强大的操作系统。通过使用本地方法，得以用Java实现了jre的与底层系统的交互，甚至JVM的一些部分就是用C写的。还有，如果使用一些Java语言本身没有提供封装的操作系统的特性时，也需要使用本地方法。　　Sun's Java：Sun的解释器是用C实现的，这使得它能像一些普通的C一样与外部交互。jre大部分是用Java实现的，它也通过一些本地方法与外界交互。例如：类java.lang.Thread的setPriority()方法是用Java实现的，但是它实现调用的是该类中的本地方法setPriority0()。这个本地方法是用C实现的，并被植入JVM内部。　　现状：目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过Java程序驱动打印机或者Java系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间的通信很发达，比如可以使用socket通信，也可以使用Web Service等等。

脚本宝典总结

以上是脚本宝典为你收集整理的JVM详解（三）——运行时数据区全部内容，希望文章能够帮你解决JVM详解（三）——运行时数据区所遇到的问题。

如果觉得脚本宝典网站内容还不错，欢迎将脚本宝典推荐好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。