玩转Java虚拟机（七）

打卡学习JVM，第七天

本人学习过程中所整理的代码，源码地址

- 栈帧（stack frame）

栈帧是一种用于帮助虚拟机执行方法调用与方法执行的数据结构，封装了方法的局部变量表、动态链接信息、方法的返回地址以及操作数栈等信息

- 符号引用&直接引用

• 静态解析：有些符号引用是在类加载阶段或是第一次使用时就会转换为直接引用

静态解析的4种情形：静态方法，父类方法，构造方法，私有方法；它们都是非虚方法，在类加载阶段就可以将符号引用转换为直接引用

public class MyTest4 {
    public static void test(){
        System.out.println("test invoked");
    }
    public static void main(String[] args) {
        test();
    }
}

使用IDEA的jclasslib插件查看字节码文件

0 invokestatic #5 <bytecode/MyTest4.test>
3 return

• 动态解析：另外一些符号引用则是在每次运行期转换为直接引用，体现为Java的多态性

1. invokeinterface：调用接口中的方法，实际上是在运行期觉得的，觉得到底调用实现该接口的哪个对象的特定方法
2. invokestatic：调用静态方法
3. invokespecial：调用自己的私有方法、构造方法（<init>）以及父类的方法
4. invokevirtual：调用虚方法，运行期动态查找的过程
5. invokedynamic：动态调用方法

即便是两个完全相同的符号引用，由于多态机制的存在，它们也可能会指向不同的直接引用

- 方法的静态分派

public class MyTest5 {
    public void test(GrandParent grandParent){
        System.out.println("grandparent");
    }
    public void test(Father father){
        System.out.println("father");
    }
    public void test(Son son){
        System.out.println("son");
    }
    public static void main(String[] args) {
        GrandParent g1 = new Father();
        GrandParent g2 = new Son();
        MyTest5 test5 = new MyTest5();
        test5.test(g1);
        test5.test(g2);
    }
}
class GrandParent {}
class Father extends GrandParent {}
class Son extends Father {}
/*grandparent
grandparent
*/

原因：方法重载是一种静态的行为，编译期就可以完全确定

比较方法重载与方法重写，我们可以得到一个结论：方法重载是静态的，是编译期行为；方法重写是动态的，是运行期行为，

GrandParent g1 = new Father();

以上代码，g1的静态类型是GrandParent，而实际类型（真正指向的类型）是Father。因此我们可以得出一个结论：变量的静态类型是不会发生变化的，而变量的实际类型则是可以发生变化的（多态的一种体现），实际类型是在运行期方可确定

- 方法的动态分派

public class MyTest6 {
    public static void main(String[] args) {
        Fruit apple = new Apple();
        Fruit orange = new Orange();
        apple.test();
        orange.test();
        apple = new Orange();
        apple.test();
    }
}
class Fruit{
    public void test(){
        System.out.println("fruit");
    }
}
class Apple extends Fruit{
    @Override
    public void test() {
        System.out.println("apple");
    }
}
class Orange extends Fruit{
    @Override
    public void test() {
        System.out.println("orange");
    }
}
/*apple
orange
orange*/

方法的动态分配涉及到一个重要概念：方法接收者

//针对方法调用动态分派的过程中，虚拟机会在类的方法区建立一个虚方法表的数据结构（virtual method table，vtable）
//针对invokeinterface指令来说，虚拟机会建立一个叫做接口方法表的数据结构（interface method table，itable）
public class MyTest7 {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();

        animal.test("hello");
        dog.test(new Date());
    }
}
class Animal{
    public void test(String str){
        System.out.println("animal str");
    }
    public void test(Date date){
        System.out.println("animal date");
    }
}
class Dog extends Animal{
    @Override
    public void test(String str) {
        System.out.println("dog str");
    }
    @Override
    public void test(Date date) {
        System.out.println("dog date");
    }
}

- 解释执行&编译执行

• 解释执行：通过解释器来读取字节码，遇到相应的指令就去执行该指令
• 编译执行：通过即使编译器（Just In Time，JIT）将字节码转换为本地机器码来执行；现代JVM会根据代码热点来生成相应的本地机器码

- 基于栈的指令集与基于寄存器的指令集之间的关系

• JVM执行指令时所采取的方式是基于栈的指令集
• 基于栈的指令集主要的操作有入栈与出栈两种
• 基于栈的指令集的优势在于它可以在不同平台之间移植，而基于寄存器的指令集是与硬件架构紧密关联，无法做到可移植
• 基于栈的指令集的缺点在于完成相同的操作，指令数量通常要比基于寄存器的指令集数量要多；基于栈的指令集是在内存中完成操作的，而基于寄存器的指令集是直接由CPU来执行的，它是在高速缓冲区进行执行的，速度要快很多。虽然虚拟机可以采用一些优化手段，但总体来说，基于栈的指令集的执行速度要慢一些。