【JVM】JVM系列之執行引擎（五）

一、前言

　　在了解了類加載的相關信息后，有必要進行更深入的學習，了解執行引擎的細節，如字節碼是如何被虛擬機執行從而完成指定功能的呢。下面，我們將進行深入的分析。

二、棧幀

　　我們知道，在虛擬機中與執行方法最相關的是棧幀，程序的執行對應着棧幀的入棧和出棧，所以棧幀對於執行引擎而言，是很重要的基礎。棧幀的基本結構之前已經有所介紹，這里只是再簡單的過一遍。

　　棧幀主要包括了局部變量表、操作數棧、動態連接、方法返回地址等信息。

　　2.1 局部變量表

　　用於存放方法參數和方法內部的局部變量。局部變量表的大小在方法的Code屬性中就已經定義好了，為max_locals的值，局部變量表的單位為slot，32位以內的類型只占用一個slot（包括returnAddress類型），64位的類型占用兩個slot。注意，對於實例方法而言，索引為0的slot存放的是this引用，之后再依次存放方法參數，定義的局部變量；slot可以被重用，當局部變量已經超出了作用域時，在作用域外在定義局部變量時，可以重用之前的slot空間。同時，局部變量沒有賦值是不能夠使用的，這和類變量和實例變量是有不同的，如下面代碼：

public void test() {
    int i;
    System.out.println(i);
}

　　這樣的代碼是錯誤的，沒有賦值不能夠使用。

　　2.2 操作數棧

　　執行方法時，存放操作數的棧，棧的深度在方法的Code屬性中已經定義好了，為max_stack的值，32位以內的類型占用一個棧單位，64為的類型占用兩個棧單位。操作數棧可以與其他棧的局部變量表共享區域，這樣可以共用一部分數據。

　　2.3 動態連接

　　動態連接是為了支持在運行期間將符號引用轉化為直接引用的操作。我們知道，每一個方法對應一個棧幀，而每一個棧幀，都包含指向對應方法的引用，這個引用就是為了支持動態連接，如invokedynamic指令。動態連接與靜態解析對應，靜態解析是在類加載（解析階段）或者第一次使用時將符號引用轉化為直接引用，動態連接則是每一次運行的時候都需要進行轉化(invokedynamic指令)。

　　2.4 方法返回地址

　　正常方法返回，返回地址為到調用該方法的指令的下一條指令的地址；異常返回，返回地址由異常表確定。方法返回時，需要恢復上層方法的局部變量表、操作數棧、將返回值壓入調用者棧幀的操作數棧、設置PC值。

三、方法調用

　　在分析了棧幀后，我們接着分析方法調用，方法調用會導致棧幀入棧，而方法調用會確定調用哪一個方法，還不會涉及到具體的方法體執行。

　　3.1 解析

　　在程序執行前就已經確定了方法調用的版本，即編譯期就確定了調用方法版本，這個版本在運行時是不可變的。靜態方法、私有方法、final方法在編譯時就可以確定具體的調用版本，靜態方法直接與類型相關、私有方法在外部不可訪問、final不可被繼承，也可唯一確定,這些方法稱為非虛方法，其他方法稱為虛方法。在類加載的解析階段就可以進行解析，如下方法調用在編譯期就可以確定方法調用的版本。　　

class Father {
    public static void print(String str) {
        System.out.println("father " + str);
    }
    
    private void show(String str) {
        System.out.println("father " + str);
    }
}

class Son extends Father {

}

public class Test {
    public static void main(String[] args) {
        Son.print("coder");
        //Father fa = new Father();
        //fa.show("cooooder");
    }
}

　　運行結果：

　　fatcher coder

　　說明：Son.print實際上調用的是Father的print方法，print方法與Father類型是相關的，而show方法時私有的方法，在Main中無法調用，只能在Father的內部調用，也是確定的。

　　invokestatic(調用靜態方法)、invokespecial(調用實例構造器<init>方法、私有方法、父類方法)都是在編譯期就可以確定版本的。

　　3.2 分派

　　分派調用與多態密切相關，分為靜態分派、動態分派、單分派、多分派。

　　1. 靜態分派

　　與靜態分派相關的就是方法的重載，重載時根據參數的靜態類型引用類型而非實際類型決定調用哪個版本。　

package com.leesf.chapter8;
/*
 * 重載方法在編譯器就可以進行確定，不需要等到運行期間
 * */
public class StaticDispatch {
    static class Human {
        //
    }
    
    static class Women extends Human {
        //
    }
    
    static class Men extends Human {
        //
    }
    
    public void sayHello(Human human) {
        System.out.println("say human");
    }
    
    public void sayHello(Women women) {
        System.out.println("say women");
    }
    
    public void sayHello(Men men) {
        System.out.println("say men");
    }
    
    public static void main(String[] args) {
        StaticDispatch ds = new StaticDispatch();
        Human women = new Women();
        Human men = new Men();
        
        ds.sayHello(women);
        ds.sayHello(men);
    }
}

　　運行結果：

　　say human
　　say human

　　說明：由於靜態類型（引用類型）為Human，在編譯期就可以確定方法的調用版本是以Human參數的方法，和實際類型無關。

　　2. 動態分派

　　與動態分派相關的就是方法的重寫，在子類中我們會重寫父類的方法，而在調用的時候根據實際類型來宣和適合的調用版本。　

package com.leesf.chapter8;

public class DynamicDispatch {
    abstract static class Human {
        abstract public void sayHello();
    }
    
    static class Women extends Human {
        @Override
        public void sayHello() {
            System.out.println("say women");
        }
    }
    
    static class Men extends Human {
        @Override
        public void sayHello() {
            System.out.println("say men");
        }
    } 
    
    public static void main(String[] args) {
        Human women = new Women();
        Human men = new Men();
        women.sayHello();
        men.sayHello();
            
    }
}

　　運行結果：

　　say women
　　say men

　　說明：此時根據實際類型選擇合適的方法調用，分別調用了women和men的sayHello()方法。

　　方法的接收者(方法的所有者)與方法的參數統稱為方法的宗量，根據分派基於多少種宗量，可以將分派划分為單分派和多分派。

　　3. 單分派與多分派

　　單分派根據一個宗量確定調用方法的版本；多分派根據多個宗量確定調用方法的版本。　　

package com.leesf.chapter8;

import com.leesf.chapter8.Test.Son;

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.hardChoice(QQ)和Father.hardChoice(_360)的指令，可以知道，在編譯期，是由多個宗量確定調用版本，是靜態多分派。動態分派過程如下，在運行期，在執行hardChoice(QQ)或者hardChoice(_360)時，已經確定了參數必須為QQ、_360，方法簽名確定，靜態類型和實際類型此時都不會對方法本身產生任何影響，而虛擬機會根據實際類型來確定調用版本，只根據一個宗量進行確定，因此，在運行時，是動態單分派。

　　3.3 動態分派的實現

　　在面向對象的編程中，會很頻繁的使用到動態分派，如何實現動態分派呢？虛擬機采用在類的方法區建立一個虛方法表(非虛方法不會出現在表中)來實現。上面程序的虛方法表如下圖所示。

　　說明：從Object類繼承的方法都會指向Object類型數據中各方法的實際入口地址。類自身的方法會指向類的數據類型中方法的實際入口地址。父類的沒有被重寫的方法在虛方法表中的索引與子類方法表中的索引相同，這樣，當類型變化時，只需要改變方法表就行，索引還是相同。方法表一般在類加載的連接階段進行初始化，准備了類變量的初始值后，方法表也初始化完畢。

　　下面我們再通過一個例子更加深入了解方法表。

　　下面幾個類的繼承關系如下

　　1. Friendly　　

package com.leesf.chapter8;

public interface Friendly {
    void sayHello();
    void sayGoodbye();
}

　　2. Dog　　

package com.leesf.chapter8;

public class Dog {
    private int wagCount = ((int) (Math.random() * 5.0)) + 1;
    
    public void sayHello() {
        System.out.println("Wag");
        for (int i = 0; i < wagCount; i++)
            System.out.println(", wag");
    }
    
    public String toString() {
        return "Woof";
    }
}

　　3. Cat　　

package com.leesf.chapter8;

public class Cat implements Friendly {
    public void eat() {
        System.out.println("Chomp, chomp, chomp");
    }
    
    public void sayHello() {
        System.out.println("Rub, rub, rub");
    }
    
    public void sayGoodbye() {
        System.out.println("Samper");
    }
    
    protected void finalze() {
        System.out.println("Meow");
    }
}

　　4. CockerSpaniel　　

package com.leesf.chapter8;

public class CockerSpaniel extends Dog implements Friendly {
    private int woofCount = ((int) (Math.random() * 4.0)) + 1;
    
    private int wimperCount = ((int) (Math.random() * 3.0)) + 1;
    
    public void sayHello() {
        super.sayHello();
        
        System.out.println("Woof");
        for (int i = 0; i < woofCount; i++) {
            System.out.println(", woof");
        }
    }
    
    public void sayGoodbye() {
        System.out.println("Wimper");
        for (int i = 0; i < wimperCount; i++) {
            System.out.println(", wimper");
        }
    }
}

　　對象映像如下圖所示

　　說明：忽略了Object的實例變量。來自超類的實例變量出現在子類實例變量之前，可以看到，Dog的實例變量wagCount的索引為1，與CockerSpaniel的索引相同，之后按照變量出現的順序依次存放。

　　Dog虛方法表

　　說明：強調，非虛方法不會出現在此表中，沒有重寫的Object的方法指向Object類型數據中的方法的實際入口地址。

　　CockerSpaniel方法表　　　　說明：可以看到被覆蓋的sayHello方法指向了CockerSpaniel類型數據，sayHello方法的索引在Dog與CockerSpaniel中是相同的。

　　Cat方法表

　　說明：由CockerSpaniel和Cat的方法表我們可以知道，sayHello方法與sayGoodbye方法在兩者的方法表中的索引是不相同的，CockerSpaniel與Cat兩個類之間沒有關系，所以接口的方法的索引可以不相同。

　　示例：

package com.leesf.chapter8;

public class Tester {
    public static void main(String[] args) {
        Dog dog = new CockerSpaniel();
        dog.sayHello();
        Friendly fr = (Friendly) dog;
        fr.sayGoodbye();
        fr = new Cat();
        fr.sayGoodbye();
    }
}

　　說明：fr首先指向CockerDaniel，然后調用了方法sayGoodbye，方法的索引為11。然后fr又指向了Cat，調用了方法sayGoodbye，方法索引為12，索引值不同，不能僅僅切換方法表，還要重新搜索（Cat的）方法表。虛擬機從接口引用調用一個方法時，它必須搜索類的方法表來找到合適的方法，並不能像之前那樣根據父類方法的索引直接可以確定子類方法的索引（因為父類的方法與子類的方法的索引相同），而是需要掃描整個方法表才能確定。這種調用接口引用的實例方法比類引用調用實例方法慢得多。

四、總結

　　通過執行引擎的學習，明白了方法在虛擬機內部如何被執行的。只有寫下來的知識理解才會更深刻，謝謝各位園友的觀看~