《深刻理解Java虚拟机》读书笔记七

时间 2019-11-11

标签深刻理解Java虚拟机读书笔记栏目 Java 繁體版

原文原文链接

第八章虚拟机字节码执行引擎html

一、运行时栈帧结构java

概述：git

栈帧是用于支持虚拟机进行方法调用的和方法执行的数据结构，他是虚拟机运行时数据区中的虚拟机栈的栈元素，栈帧存储了方法的局部变量，操做数栈，动态链接和方法返回值等信息，每一个方法从调用开始到执行完成的过程都对应着一个栈帧在虚拟机栈里面从入栈到出栈的过程。
一个线程中的方法调用链会很长，只有位于栈顶的栈帧才有效，称为当前栈帧，与这个栈帧相关联的方法称为当前方法。执行引擎运行全部字节码指令都只针对当前栈帧进行操做。

局部变量表：github

局部变量表是一组变量存储空间，用于存放方法参数和方法内部定义的局部变量。
在Java程序编译为class文件时就在方法的code属性的max_locals数据项中肯定该方法所须要分配的局部变量表的最大容量。局部变量表的容量已变量槽为最小单位。
虚拟机经过索引定位的方式使用局部变量表，索引值的范围从0开始至局部变量表最大Slot数量。
在方法执行时，虚拟机是使用局部变量表完成参数值到参数变量列表的传递过程的，若是是实例方法（非static的方法），那么局部变量表中第0位索引的Slot默认是用于传递方法所属对象实例的引用，在方法中能够经过关键字“this”来访问这个隐含的参数。其他参数则按照参数表的顺序来排列，占用从1开始的局部变量Slot，参数表分配完毕后，再根据方法体内部定义的变量顺序和做用域分配其他的Slot。

局部变量表中的Slot是可重用的，方法体中定义的变量，其做用域并不必定会覆盖整个方法体，若是当前字节码PC计数器的值已经超出了某个变量的做用域，那么这个变量对应的Slot就能够交给其余变量使用。这样的设计不只仅是为了节省栈空间，在某些状况下Slot的复用会直接影响到系统的垃圾收集行为。

package com.ecut.stack;

/**
 * -verbose:gc
 */
public class SlotTest {

    public static void main(String[] args) {
        //placeholder的做用域被限制在花括号以内
        {
            byte[] placeholder = new byte[64 * 1024 * 1024];
        }
        //若是不增长这行，即没有任何对局部变量表的读写操做，placeholder本来所占用的Slot尚未被其余变量所复用，因此做为GC Roots一部分的局部变量表仍然保持着对它的关联。
        int a = 0 ;
        System.gc();
    }
}

运行结果：缓存

[GC (System.gc())  68864K->66256K(125952K), 0.0020403 secs]
[Full GC (System.gc())  66256K->664K(125952K), 0.0095304 secs]

局部变量定义了可是没有初始化时不能使用的。

操做数栈：安全

也称为操做栈，他是一个后入先出栈的栈，同局部变量同样，操做数栈的最大深度也在编译的时候写入到了code属性的max_stacks数据中，在方法执行的任什么时候候，操做数栈的深度都不会超过在max_stacks数据项中设定的最大值。
当一个方法刚刚开始执行的时候，这个方法的操做数栈是空的，在方法的执行过程当中，会有各类字节码指令向操做数栈中写入和提取内容，也就是入栈出栈操做。
Java虚拟机的解释执行引擎称为“基于栈的执行引擎”，其中所指的“栈”就是操做数栈。

动态链接：数据结构

每一个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支持方法调用过程当中的动态链接。
字节码中的方法调用指令就以常量池中指向方法的符号引用为参数，这些符号引用一部分会在类加载阶段或第一次使用的时候转化为直接引用，这种转化称为静态解析。另一部分将在每一次的运行期间转化为直接引用，这部分称为动态链接。

方法返回地址：架构

第一种退出方式是执行引擎遇到任意一个方法返回的字节码指令，这时候可能会有返回值传递给上层的方法调用者（调用当前方法的方法称为调用者），是否有返回值和返回值的类型将根据遇到何种方法返回指令来决定，这种退出方法的方式称为正常完成出口（Normal Method Invocation Completion）。
另一种退出方式是，在方法执行过程当中遇到了异常，而且这个异常没有在方法体内获得处理，不管是Java虚拟机内部产生的异常，仍是代码中使用athrow字节码指令产生的异常，只要在本方法的异常表中没有搜索到匹配的异常处理器，就会致使方法退出，这种退出方法的方式称为异常完成出口（Abrupt Method Invocation Completion）。一个方法使用异常完成出口的方式退出，是不会给它的上层调用者产生任何返回值的。
方法正常退出时，调用者的PC计数器的值就能够做为返回地址，栈帧中极可能会保存这个计数器值。而方法异常退出时，返回地址是要经过异常处理器来肯定的，栈帧中通常不会保存这部分信息。
方法退出的过程实际上等同于把当前栈帧出栈，所以退出时可能执行的操做有：恢复上层方法的局部变量表和操做数栈，把返回值（若是有的话）压入调用者栈帧的操做数栈中，调整PC计数器的值以指向方法调用指令后面的一条指令等。

附加信息：jvm

虚拟机规范容许具体的虚拟机实现增长一些规范里没有描述的信息到栈帧之中，例如与调试相关的信息。
通常会把动态链接、方法返回地址与其余附加信息所有归为一类，称为栈帧信息。

二、方法调用ide

解析调用：

解析就是将方法的符号引用转化成直接引用的，解析的前提是方法须在方法运行前就肯定一个可调用的版本，而且这个版本在运行阶段是不可改变的（编译期可知，运行期不可变）。
只有用invokestatic和invokespecial指令调用的方法，均可以在解析阶段肯定调用版本，符合此条件的有静态方法,私有方法,实例构造器和父类方法四类。它们在类加载时即把符号引用解析为该方法的直接引用.这些方法能够称为非虚方法。
解析调用是一个静态过程，编译期间就能够肯定，分派调用多是静态的也多是动态的，是实现多态性的体现。

静态分派：

package com.ecut.stack;

public class StaticDispatch {

    static abstract class Human {
    }

    static class Man extends Human {
    }

    static class Woman extends Human {
    }

    public static void sayHello(Human guy) {
        System.out.println("hello guy");
    }

    public static void sayHello(Man guy) {
        System.out.println("hello gentleman");
    }

    public static void sayHello(Woman guy) {
        System.out.println("hello  lady");
    }

    public static void main(String[] args) {
        Human man = new Man();

        Human woman = new Woman();

        sayHello(man);

        sayHello(woman);
    }
}

运行结果：

hello guy
hello guy

“Human”称为变量的静态类型，后面的“Man”称为变量的实际类型。虚拟机（准确地说是编译器）在重载时是经过参数的静态类型而不是实际类型做为断定依据的。所以，在编译阶段，Javac编译器会根据参数的静态类型决定使用哪一个重载版本。

全部依赖静态类型来定位方法执行版本的分派动做称为静态分派。静态分派的典型应用是方法重载。静态分派发生在编译阶段，所以肯定静态分派的动做实际上不是由虚拟机来执行的。

编译器虽然能肯定出方法的重载版本，但在不少状况下这个重载版本并非“惟一的”，每每只能肯定一个“更加合适的”版本。

package com.ecut.stack;

import java.io.Serializable;

public class Overload {
    public static void sayHello(Object arg) {
        System.out.println("hello Object");
    }

    public static void sayHello(int arg) {
        System.out.println("hello int");
    }

    public static void sayHello(long arg) {
        System.out.println("hello long");
    }

    public static void sayHello(Character arg) {
        System.out.println("hello Character");
    }

    public static void sayHello(char arg) {
        System.out.println("hello char");
    }

    public static void sayHello(char... arg) {
        System.out.println("hello char……");
    }

    public static void sayHello(Serializable arg) {
        System.out.println("hello Serializable");
    }

    public static void main(String[] args) {
        sayHello('a');
    }
}

运行结果：

hello char

这很好理解，'a'是一个char类型的数据，天然会寻找参数类型为char的重载方法，若是注释掉sayHello（char arg）方法，那输出会变为：

hello int

这时发生了一次自动类型转换，'a'除了能够表明一个字符串，还能够表明数字97（字符'a'的Unicode数值为十进制数字97），所以参数类型为int的重载也是合适的。咱们继续注释掉sayHello（int arg）方法，那输出会变为：

hello long

这时发生了两次自动类型转换，'a'转型为整数97以后，进一步转型为长整数97L，匹配了参数类型为long的重载。笔者在代码中没有写其余的类型如float、double等的重载，不过实际上自动转型还能继续发生屡次，按照char-＞int-＞long-＞float-＞double的顺序转型进行匹配。但不会匹配到byte和short类型的重载，由于char到byte或short的转型是不安全的。咱们继续注释掉sayHello（long arg）方法，那输出会变为：

hello Character

这时发生了一次自动装箱，'a'被包装为它的封装类型java.lang.Character，因此匹配到了参数类型为Character的重载，继续注释掉sayHello（Character arg）方法，那输出会变为：

hello Serializable

这个输出可能会让人感受摸不着头脑，一个字符或数字与序列化有什么关系？出现hello Serializable，是由于java.lang.Serializable是java.lang.Character类实现的一个接口，当自动装箱以后发现仍是找不到装箱类，可是找到了装箱类实现了的接口类型，因此紧接着又发生一次自动转型。char能够转型成int，可是Character是绝对不会转型为Integer的，它只能安全地转型为它实现的接口或父类。Character还实现了另一个接口java.lang.Comparable＜Character＞，若是同时出现两个参数分别为Serializable和Comparable＜Character＞的重载方法，那它们在此时的优先级是同样的。编译器没法肯定要自动转型为哪一种类型，会提示类型模糊，拒绝编译。程序必须在调用时显式地指定字面量的静态类型，如：sayHello（（Comparable＜Character＞）'a'），才能编译经过。下面继续注释掉sayHello（Serializable arg）方法，输出会变为：

hello Object

这时是char装箱后转型为父类了，若是有多个父类，那将在继承关系中从下往上开始搜索，越接近上层的优先级越低。即便方法调用传入的参数值为null时，这个规则仍然适用。咱们把sayHello（Object arg）也注释掉，输出将会变为：

hello char……

解析与分派这二者之间的关系并非二选一的排他关系，它们是在不一样层次上去筛选、肯定目标方法的过程。例如，前面说过，静态方法会在类加载期就进行解析，而静态方法显然也是能够拥有重载版本的，选择重载版本的过程也是经过静态分派完成的。

动态分派：

package com.ecut.stack;

public class DynamicDispatch {
    static abstract class Human {
        protected abstract void sayHello();
    }

    static class Man extends Human {
        @Override
        protected void sayHello() {
            System.out.println("man say hello");
        }
    }

    static class Woman extends Human {
        @Override
        protected void sayHello() {
            System.out.println("woman say hello");
        }
    }

    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();
        man.sayHello();
        woman.sayHello();
        man = new Woman();
        man.sayHello();
    }
}

运行结果以下：

man say hello
woman say hello
woman say hello

使用javap -verbose DynamicDispatch .class命令

invokevirtual指令的运行时解析过程大体分为如下几个步骤：

找到操做数栈顶的第一个元素所指向的对象的实际类型，记做C。
若是在类型C中找到与常量中的描述符和简单名称都相符的方法，则进行访问权限校验，若是经过则返回这个方法的直接引用，查找过程结束；若是不经过，则返回java.lang.IllegalAccessError异常。
不然，按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。
若是始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。

因为invokevirtual指令执行的第一步就是在运行期肯定接收者的实际类型，因此两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不一样的直接引用上，这个过程就是Java语言中方法重写的本质。咱们把这种在运行期根据实际类型肯定方法执行版本的分派过程称为动态分派。

单分派与多分派:

方法的接收者与方法的参数统称为方法的宗量
根据分派基于多少种宗量，能够将分派划分为单分派和多分派两种。单分派是根据一个宗量对目标方法进行选择，多分派则是根据多于一个宗量对目标方法进行选择。
```
package com.ecut.stack;

public class Dispatch {
    static class QQ {
    }

    static class _360 {
    }

    public static class Father {
        public void hardChoice(QQ arg) {
            System.out.println("father choose qq");
        }

        public void hardChoice(_360 arg) {
            System.out.println("father choose 360");
        }
    }

    public static class Son extends Father {
        public void hardChoice(QQ arg) {
            System.out.println("son choose qq");
        }

        public void hardChoice(_360 arg) {
            System.out.println("son choose 360");
        }
    }

    public static void main(String[] args) {
        Father father = new Father();
        Father son = new Son();
        father.hardChoice(new _360());
        son.hardChoice(new QQ());
    }
}
```
运行结果以下：
```
father choose 360
son choose qq
```
咱们来看看编译阶段编译器的选择过程，也就是静态分派的过程。这时选择目标方法的依据有两点：一是静态类型是Father仍是Son，二是方法参数是QQ仍是360。此次选择结果的最终产物是产生了两条invokevirtual指令，两条指令的参数分别为常量池中指向Father.hardChoice（360）及Father.hardChoice（QQ）方法的符号引用。由于是根据两个宗量进行选择，因此Java语言的静态分派属于多分派类型。

再看看运行阶段虚拟机的选择，也就是动态分派的过程。在执行“son.hardChoice（new QQ（））”这句代码时，更准确地说，是在执行这句代码所对应的invokevirtual指令时，因为编译期已经决定目标方法的签名必须为hardChoice（QQ），虚拟机此时不会关心传递过来的参数“QQ”究竟是“腾讯QQ”仍是“奇瑞QQ”，由于这时参数的静态类型、实际类型都对方法的选择不会构成任何影响，惟一能够影响虚拟机选择的因素只有此方法的接受者的实际类型是Father仍是Son。由于只有一个宗量做为选择依据，因此Java语言的动态分派属于单分派类型。

虚拟机动态分派的实现：

因为动态分派是很是频繁的动做，并且动态分派的方法版本选择过程须要运行时在类的方法元数据中搜索合适的目标方法，所以在虚拟机的实际实现中基于性能的考虑，大部分实现都不会真正地进行如此频繁的搜索。面对这种状况，最经常使用的“稳定优化”手段就是为类在方法区中创建一个虚方法表（Vritual Method Table，也称为vtable，与此对应的，在invokeinterface执行时也会用到接口方法表——Inteface Method Table，简称itable），使用虚方法表索引来代替元数据查找以提升性能。
虚方法表中存放着各个方法的实际入口地址。若是某个方法在子类中没有被重写，那子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的，都指向父类的实现入口。若是子类中重写了这个方法，子类方法表中的地址将会替换为指向子类实现版本的入口地址。Son重写了来自Father的所有方法，所以Son的方法表没有指向Father类型数据的箭头。可是Son和Father都没有重写来自Object的方法，因此它们的方法表中全部从Object继承来的方法都指向了Object的数据类型。

方法表通常在类加载的链接阶段进行初始化，准备了类的变量初始值后，虚拟机会把该类的方法表也初始化完毕。

动态类型语言支持：

动态类型语言的关键特征是它的类型检查的主体过程是在运行期而不是编译期，知足这个特征的语言有不少，经常使用的包括：APL、Clojure、Erlang、Groovy、JavaScript、Jython、Lisp、Lua、PHP、Prolog、Python、Ruby、Smalltalk和Tcl等。
相对的，在编译期就进行类型检查过程的语言（如C++和Java等）就是最经常使用的静态类型语言。

JDK 1.7实现了JSR-292，新加入的java.lang.invoke包。这个包的主要目的是在以前单纯依靠符号引用来肯定调用的目标方法这种方式之外，提供一种新的动态肯定目标方法的机制，称为MethodHandle。

package com.ecut.stack;

import static java.lang.invoke.MethodHandles.lookup;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodType;
public class MethodHandleTest{
    static class ClassA{
        public void println(String s){
            System.out.println(s);
        }
    }
    public static void main(String[] args)throws Throwable{
        Object obj=System.currentTimeMillis()%2==0?System.out:new ClassA();
        /*不管obj最终是哪一个实现类，下面这句都能正确调用到println方法*/
        getPrintlnMH(obj).invokeExact("MethodHandleTest");
    }
    private static MethodHandle getPrintlnMH(Object reveiver) throws Throwable{
        /*MethodType：表明“方法类型”，包含了方法的返回值（methodType（）的第一个参数）和具体参数（methodType（）第二个及之后的参数）*/
        MethodType mt=MethodType.methodType(void.class,String.class);
        /*lookup（）方法来自于MethodHandles.lookup，这句的做用是在指定类中查找符合给定的方法名称、方法类型，而且符合调用权限的方法句柄
        由于这里调用的是一个虚方法，按照Java语言的规则，方法第一个参数是隐式的，表明该方法的接收者，也便是this指向的对象，
　　　　这个参数之前是放在参数列表中进行传递的，而如今提供了bindTo（）方法来完成这件事情*/
        return lookup().findVirtual(reveiver.getClass(),"println",mt).bindTo(reveiver);
    }
}

MethodHandle的基本用途，不管obj是何种类型（临时定义的ClassA抑或是实现PrintStream接口的实现类System.out），均可以正确地调用到println（）方法。

MethodHandle与Reflection的区别
1. 从本质上讲，Reflection和MethodHandle机制都是在模拟方法调用，但Reflection是在模拟Java代码层次的方法调用，而MethodHandle是在模拟字节码层次的方法调用。在MethodHandles.lookup中的3个方法——findStatic（）、findVirtual（）、findSpecial（）正是为了对应于invokestatic、invokevirtual＆invokeinterface和invokespecial这几条字节码指令的执行权限校验行为，而这些底层细节在使用Reflection API时是不须要关心的。
2. Reflection中的java.lang.reflect.Method对象远比MethodHandle机制中的java.lang.invoke.MethodHandle对象所包含的信息多。前者是方法在Java一端的全面映像，包含了方法的签名、描述符以及方法属性表中各类属性的Java端表示方式，还包含执行权限等的运行期信息。然后者仅仅包含与执行该方法相关的信息。用通俗的话来说，Reflection是重量级，而MethodHandle是轻量级。
3. 因为MethodHandle是对字节码的方法指令调用的模拟，因此理论上虚拟机在这方面作的各类优化（如方法内联），在MethodHandle上也应当能够采用相似思路去支持（但目前实现还不完善）。而经过反射去调用方法则不行。
4. MethodHandle与Reflection除了上面列举的区别外，最关键的一点还在于去掉前面讨论施加的前提“仅站在Java语言的角度来看”：Reflection API的设计目标是只为Java语言服务的，而MethodHandle则设计成可服务于全部Java虚拟机之上的语言，其中也包括Java语言。
nvokedynamic指令与MethodHandle机制的做用是同样的，都是为了解决原有4条“invoke*”指令方法分派规则固化在虚拟机之中的问题，把如何查找目标方法的决定权从虚拟机转嫁到具体用户代码之中，让用户（包含其余语言的设计者）有更高的自由度。

三、基于栈的字节码解释引擎

解释执行的过程：

执行和编译的两种选择：

基于栈的指令集与基于寄存器的指令集
基于栈的指令集主要的优势就是可移植
栈架构指令集的主要缺点是执行速度相对来讲会稍慢一些，由于出栈、入栈操做自己就产生了至关多的指令数量。更重要的是，栈实如今内存之中，频繁的栈访问也就意味着频繁的内存访问，相对于处理器来讲，内存始终是执行速度的瓶颈。尽管虚拟机能够采起栈顶缓存的手段，把最经常使用的操做映射到寄存器中避免直接内存访问，但这也只能是优化措施而不是解决本质问题的方法。因为指令数量和内存访问的缘由，因此致使了栈架构指令集的执行速度会相对较慢。

源码地址：

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

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

http://www.javashuo.com/article/p-czvetgax-u.html