深刻理解java虚拟机（5）---字节码执行引擎

字节码是什么东西？

如下是百度的解释：

字节码（Byte-code）是一种包含执行程序、由一序列 op 代码/数据对组成的二进制文件。字节码是一种中间码，它比机器码更抽象。

它常常被看做是包含一个执行程序的二进制文件，更像一个对象模型。字节码被这样叫是由于一般每一个 opcode 是一字节长，

可是指令码的长度是变化的。每一个指令有从 0 到 255（或十六进制的： 00 到FF)的一字节操做码，被参数例如寄存器或内存地址跟随。

 

说了这么多，你可能仍是不明白究竟是什么东西。好吧，简单点，就是java编译之后的那个东东，“.class”文件。

因此class文件就是字节码文件，是由虚拟机执行的文件。也就是java语言和C & C++语言的区别就是，整个编译执行过程多了一个虚拟

机这一步。这个在“深刻理解java虚拟机（3）---类的结构” 一文中已经解释，这是一个里程碑式的设计。上一节讲了虚拟机是如何加载

一个class的，这一节就讲解虚拟机是如何执行class文件的。

 

java虚拟机规范，规定了虚拟机字节码的执行概念模型。具体的虚拟机能够有不一样的实现。

运行时栈帧结构

栈是每一个线程独有的内存。

栈帧存储了局部变量表，操做数栈，动态链接，和返回地址等。

每个方法的执行 对应的一个栈帧在虚拟机里面从如栈到出栈的过程。

只有位于栈顶的栈帧才有有效的，对应的方法称为当前方法。

执行引擎运行的全部指令只针对当前栈帧和当前方法。

1.局部变量表

局部变量表存放的一组变量的存储空间。存放方法参数和方法内部定义的局部变量表。

在java编译成class的时候，已经肯定了局部变量表所需分配的最大容量。

局部变量表的最小单位是一个Slot。

虚拟机规范没有明确规定一个Slot占多少大小。只是规定，它能够放下boolean,byte,...reference &return address.

reference 是指一个对象实例的引用。关于reference的大小，目前没有明确的指定大小。可是咱们能够理解为它就是相似C++中的指针。

局部变量表的读取方式是索引，从0开始。因此局部变量表能够简单理解为就是一个表.

局部变量表的分配顺序以下：

this 引用。能够认为是隐式参数。

方法的参数表。

根据局部变量顺序，分配Solt。

一个变量一个solt，64为的占2个solt。java中明确64位的是long & double

为了尽量的节约局部变量表，Solt能够重用。

注意：局部变量只给予分配的内存，没有class对象的准备阶段，因此局部变量在使用前，必须先赋值。

2.操做数栈

操做数栈在概念上很像寄存器。

java虚拟机没法使用寄存器，因此就有操做数栈来存放数据。

虚拟机把操做数栈做为它的工做区——大多数指令都要从这里弹出数据，执行运算，而后把结果压回操做数栈。

好比，iadd指令就要从操做数栈中弹出两个整数，执行加法运算，其结果又压回到操做数栈中，看看下面的示例，

它演示了虚拟机是如何把两个int类型的局部变量相加，再把结果保存到第三个局部变量的：

begin

iload_0 // push the int in local variable 0 onto the stack

iload_1 // push the int in local variable 1 onto the stack

iadd // pop two ints, add them, push result

istore_2 // pop int, store into local variable 2

end

操做数栈 的数据读取、写入就是出栈和如栈操做。

3.动态链接

每一个栈帧都包含一个指向运行时常量池的引用，持有这个引用是为了支持动态链接。

符号池的引用，有一部分是在第一次使用或者初始化的时候就肯定下来，这个称为静态引用。

还有一部分是在每次执行的时候采起肯定，这个就是动态链接。

4.方法返回地址

方法只有2中退出方式，正常状况下，遇到return指令退出。还有就是异常退出。

正常状况：通常状况下，栈帧会保存 在程序计数器中的调用者的地址。虚拟机经过这个方式，执行方法调用者的地址，

而后把返回值压入调用者中的操做数栈。

异常状况：方法不会返回任何值，返回地址有异常表来肯定，栈帧通常不存储信息。

5.方法调用

方法调用阶段不是执行该方法，而仅仅时确认要调用那个方法。class文件在编译阶段没有链接这一过程，、

因此动态链接这个在C++就已经有的技术，在java运用到了一个新的高度。全部的函数（除了私有方法，构造方法 & 静态方法，下同），理论上

均可以时C++里面的虚函数。因此全部的函数都须要经过动态绑定来肯定“明确”的函数实体。

解析

全部方法调用的目标方法都是常量池中的符号引用。在类的加载解析阶段，会将一部分目标方法转化为直接引用。（能够理解为具体方法的直接地址）

能够转化的方法，主要为静态方法 & 私有方法。

Java虚拟机提供5中方法调用命令：

invokestatic:调用静态方法

invokespecial:调用构造器，私有方法和父类方法

invokevirtual:调用虚方法

invokeinterface:调用接口方法

invokedynamic：如今运行时动态解析出该方法，而后执行。

invokestatic & invokespecial 对应的方法，都是在加载解析后，能够直接肯定的。因此这些方法为非虚方法。

java规定 final修饰的是一种非虚方法。

分派

静态分派

先看一个例子：

package com.joyfulmath.jvmexample.dispatch;

import com.joyfulmath.jvmexample.TraceLog;

/**
 * @author deman.lu
 * @version on 2016-05-19 13:53
 */
public class StaticDispatch {
    static abstract class Human{

    }

    static class Man extends Human{

    }

    static class Woman extends Human{

    }

    public void sayHello(Human guy)
    {
        TraceLog.i("Hello guy!");
    }

    public void sayHello(Man man)
    {
        TraceLog.i("Hello gentleman!");
    }

    public void sayHello(Woman man)
    {
        TraceLog.i("Hello lady!");
    }

    public static void action()
    {
        Human man = new Man();
        Human woman = new Woman();
        StaticDispatch dispatch = new StaticDispatch();
        dispatch.sayHello(man);
        dispatch.sayHello(woman);
    }
}

05-19 13:58:05.538 14881-14881/com.joyfulmath.jvmexample I/StaticDispatch: sayHello: Hello guy! [at (StaticDispatch.java:24)]
05-19 13:58:05.539 14881-14881/com.joyfulmath.jvmexample I/StaticDispatch: sayHello: Hello guy! [at (StaticDispatch.java:24)]

结果执行了public void sayHello(Human guy)函数。这不是应该多态吗？

Human man = new Man();

这里的Human咱们理解为静态类型，后面的Man是实际类型。咱们在编译器只知道静态类型，后面的实际类型等到动态链接的时候才知道。

因此对于sayHello方法，虚拟机在重载时，是经过参数的静态类型，而不是实际类型来判断使用那个方法的。

若是对类型作强制转换：

    public static void action()
    {
        Human man = new Man();
        Human woman = new Woman();
        StaticDispatch dispatch = new StaticDispatch();
        dispatch.sayHello(man);
        dispatch.sayHello(woman);
        dispatch.sayHello((Man)man);
        dispatch.sayHello((Woman)woman);
    }
05-19 14:08:29.000 21838-21838/com.joyfulmath.jvmexample I/StaticDispatch: sayHello: Hello guy! [at (StaticDispatch.java:24)]
05-19 14:08:29.001 21838-21838/com.joyfulmath.jvmexample I/StaticDispatch: sayHello: Hello guy! [at (StaticDispatch.java:24)]
05-19 14:08:29.001 21838-21838/com.joyfulmath.jvmexample I/StaticDispatch: sayHello: Hello gentleman! [at (StaticDispatch.java:29)]
05-19 14:08:29.002 21838-21838/com.joyfulmath.jvmexample I/StaticDispatch: sayHello: Hello lady! [at (StaticDispatch.java:34)]

若是强转了之后，类型也跟着变化了。

静态分配的典型应用是方法重载。可是方法重载有时候不是惟一的，因此只能选合适的。

好比：

    public void sayHello(int data)
    {
        TraceLog.i("Hello int!");
    }

    public void sayHello(long  data)
    {
        TraceLog.i("Hello long");
    }

当sayHello（1）的时候，通常状况下会调用int型的方法，可是若是注释调，只有long型的方法，long型参数方法就会被调用。

 

动态分派

上面讲的是重载，这里是重写（@Override）

package com.joyfulmath.jvmexample.dispatch;

import com.joyfulmath.jvmexample.TraceLog;

/**
 * @author deman.lu
 * @version on 2016-05-19 14:26
 */
public class DynamicDispatch {
    static abstract class Human{
        protected abstract void sayHello();
    }

    static class Man extends Human{

        @Override
        protected void sayHello() {
            TraceLog.i("Hello gentleman!");
        }
    }

    static class Woman extends Human{

        @Override
        protected void sayHello() {
            TraceLog.i("Hello lady!");
        }
    }

    public static void action()
    {
        Human man = new Man();
        Human woman = new Woman();
        man.sayHello();
        woman.sayHello();
        man = new Woman();
        man.sayHello();
    }
}

先来看上面标红的这句：方法要解析man 的sayhello，问题是man是什么东西，我在解析的时候，是不知道的。因此“man.sayHello();”具体执行的那个类的方法，是须要在虚拟机

动态链接的时候才知道，这个就是多态。若是使用javap分析就能够知道这句话，在class文件里面是ynamicDispatch$Human: sayHello. 是的class文件不知道这个sayhello到底要去

调哪一个方法。

invokevirtual指令解析的过程大概以下：首先在操做数栈里第一个元素的实际类型，即为C。

若是在类型C中找到与常量描述符相同的类名和方法，则权限校验经过后，即为找到该法方法，则返回这个方法的直接引用。

不然，对C的父类进行依次查找。

这个过程通俗一点就是，先从当前类里面寻找“同名”的该方法，若是没有，就从C的父类里面找，知道找到为止！

这个找到的方法，就是咱们实际要调的方法。

若是找不到，就是exception。通常状况下，编译工具会帮咱们避免这种状况。

单分派和多分派

概念上理解比较麻烦，说白了一点就是重载和重写都存在的状况：

package com.joyfulmath.jvmexample.dispatch;

import com.joyfulmath.jvmexample.TraceLog;

/**
 * @author deman.lu
 * @version on 2016-05-19 15:02
 */
public class MultiDispatch {
    static class QQ{}
    static class _360{}

    public static class Father{
        public void hardChoice(QQ qq){
            TraceLog.i("Father QQ");
        }

        public void hardChoice(_360 aa){
            TraceLog.i("Father 360");
        }
    }

    public static class Son extends Father{
        public void hardChoice(QQ qq){
            TraceLog.i("Son QQ");
        }

        public void hardChoice(_360 aa){
            TraceLog.i("Son 360");
        }
    }

    public static void action()
    {
        Father father = new Father();
        Father son = new Son();
        father.hardChoice(new _360());
        son.hardChoice(new QQ());
    }
}

05-19 15:07:44.429 29011-29011/com.joyfulmath.jvmexample I/MultiDispatch$Father: hardChoice: Father 360 [at (MultiDispatch.java:19)]
05-19 15:07:44.429 29011-29011/com.joyfulmath.jvmexample I/MultiDispatch$Son: hardChoice: Son QQ [at (MultiDispatch.java:25)]

结果没有任何悬念，可是过程仍是须要明确的。hardChoice的选择是在静态编译的时候就确认的。

而son.hardchoise 已经确认了函数的类型，只是须要进一步确认实体类型。因此动态链接是单分派。

 

动态语言支持：

使用C++语言能够定义一个调用方法：

void sort（int list[],const int size，int （*compare）(int,int)）;

可是java很难作到这一点，

void sort（List list，Compare c);Compare 通常要用接口实现。

在java 1.7 有一种方法能够支持该功能 MethodHandle。

这部份内容，因为我本地环境没法配置还调用，将会再后续更新。

 

铺垫了这么多，下面来说讲字节码的执行

6.基于栈的字节码执行引擎

基于栈的指令集 和基于寄存器的指令集。

先看一个加法过程：

iconst_1

iconst_1

iadd

istore_0

这是基于栈的，也就是上文说的操做数栈。

先把2个元素要入栈，而后相加，放回栈顶，而后把栈顶的值存在slot 0里面。

基于寄存器的就不解释了。

基于寄存器 和基于栈的指令集如今都存在。因此很难说孰优孰劣。

基于栈的指令集 是和硬件无关的，而基于寄存器则依赖于硬件基础。基于寄存器在效率上优点。

可是虚拟机的出现，就是为了提供跨平台的支持，因此jvm的执行引擎是基于栈的指令集。

    public int calc()
    {
        int a = 100;
        int b = 200;
        int c = 300;
        return (a+b)*c;
    }

如下是javap的分析结果：

 

如下图片描述了整个执行过程当中代码，操做数栈，& 局部变量表的变化。

 

 

这些过程只是一个概念模型，实际虚拟机会有不少优化的状况。

声明：本文相关图片来之参考书面，相关版权归原做者全部。

参考：

《深刻理解java虚拟机》 周志明