2. 程式人生 > >深入理解 Java 虛擬機器（九）方法呼叫

深入理解 Java 虛擬機器（九）方法呼叫

阿新 • • 發佈：2018-12-10

方法呼叫

方法呼叫不等同於方法執行，方法呼叫階段唯一任務就是確定被呼叫方法的版本（即呼叫哪一個方法），暫時還不涉及方法內部的具體執行過程。一切方法呼叫在 Class 檔案裡面儲存的都只是符號引用，需要在類載入期間，甚至到執行期間才能確定目標方法的直接引用。

解析

在類載入的解析階段，會把其中一部分方法的符號引用轉化為直接引用，解析成立的前提是：方法在程式真正執行之前就有一個可確定的呼叫版本，並且這個方法的呼叫版本在執行期是不可改變的，這類方法的呼叫稱為解析。

在 Java 中，符合編譯期可知，執行期不可變的要求的方法主要包括靜態方法和私有方法，因此它們都適合在類載入階段進行解析。

Java 虛擬機器提供了 5 條方法呼叫的位元組碼指令： 1) invokestatic：呼叫靜態方法 2) invokespecial：呼叫 < init> 方法、私有方法和父類方法 3) invokevirtual：呼叫所有的虛方法 4) invokeinterface：呼叫介面方法，在執行時再確定一個實現此介面的物件 5) invokedynamic：執行時動態解析出呼叫點限定符所引用的方法，然後再執行

前 4 條指令的分派邏輯是固定在 Java 虛擬機器內部的，而 invokedynamic 指令的分派邏輯是由使用者所設定的引導方法決定的。只要能被 invokestatic、invokespecial 指令呼叫的方法，都可以在解析階段確定唯一的呼叫版本，它們在類載入的時候就會把符號引用解析為該方法的直接引用，這些方法可以稱為非需方法，其它方法可以稱為虛方法。

此外還有一種方法，就是被 final 修飾的方法，雖然 final 方法是使用 invokevirtual 指令來呼叫的，但 Java 語言規範中明確說明了 final 方法是一種非虛方法。

分派

解析是一個靜態的過程，而分配呼叫可能是靜態的，也可能是動態的，根據分配的宗量（後面會說明）數可以分配為單分派和多分派，因此共有靜態單分派、靜態多分派、動態單分派、動態多分派 4 種分派情況。

靜態分派

有如下程式碼：

public class StaticDispatch {

    static abstract class Human {
    }

    static class Man extends Human {
    }

    static class Woman extends Human {
    }

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

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

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

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

}

輸出結果：

hello,guy!
hello,guy!

虛擬機器在過載時是通過引數的靜態型別而不是實際型別作為判定依據的，因此，在編譯階段，Javac 編譯器會根據引數的靜態型別決定使用哪個過載版本。

所有依賴靜態型別來決定方法執行版本的分派動作成為靜態分派，靜態分派發生在編譯階段。另外，雖然編譯器能確定方法的過載版本，但很多情況下這個過載版本並不是唯一的，往往只能確定一個更合適的版本，比如：

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

但它有一個很神奇的地方，假如註釋掉方法 sayHello(char arg)，那麼它會輸出：

hello int

繼續註釋下去，發現 ‘a’ 會按優先順序依次被轉型為 char、int、long、Character、Serializeable(Character 實現的介面之一)、Object、char…，可見變長引數的過載優先順序是最低的，但注意，’a’ 不能轉型為 Integer、Long 等型別。

不過，這種程式碼相當於“茴香豆的茴有幾種寫法”的研究，實際程式設計應儘量避免這種情況。

2.2.2 動態分派

動態分派和覆蓋（Override，複寫、重寫）有著很密切的關聯，比如：

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

man、woman 這兩個物件是將要執行的 sayHello() 方法的所有者，稱為接收者。

使用 javap 分析這段程式碼：

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: new           #2                  // class org/fenixsoft/polymorphic/DynamicDispatch$Man
         3: dup
         4: invokespecial #3                  // Method org/fenixsoft/polymorphic/DynamicDispatch$Man."<init>":()V
         7: astore_1
         8: new           #4                  // class org/fenixsoft/polymorphic/DynamicDispatch$Woman
        11: dup
        12: invokespecial #5                  // Method org/fenixsoft/polymorphic/DynamicDispatch$Woman."<init>":()V
        15: astore_2
        16: aload_1
        17: invokevirtual #6                  // Method org/fenixsoft/polymorphic/DynamicDispatch$Human.sayHello:()V
        20: aload_2
        21: invokevirtual #6                  // Method org/fenixsoft/polymorphic/DynamicDispatch$Human.sayHello:()V
        24: new           #4                  // class org/fenixsoft/polymorphic/DynamicDispatch$Woman
        27: dup
        28: invokespecial #5                  // Method org/fenixsoft/polymorphic/DynamicDispatch$Woman."<init>":()V
        31: astore_1
        32: aload_1
        33: invokevirtual #6                  // Method org/fenixsoft/polymorphic/DynamicDispatch$Human.sayHello:()V
        36: return

可以發現，第 17、33 條語句中的引數都是同一個，但最終執行的目標方法不同，這是 invokevirtual 的特性決定的，invokevirtual 指令的執行時解析過程大致可以分為一下幾個步驟：

1) 找到運算元棧頂的第一個元素所指向的物件的實際型別 C

2) 如果在 C 中找到與常量中的描述符和簡單名稱都相符的方法，則進行訪問許可權校驗，通過則返回直接引用，查詢結束；否則丟擲 java.lang.IllegalAccessError 異常

3) 否則，按照繼承關係從下往上一次對 C 的各個父類進行第 2 步的搜尋和驗證過程

4) 如果沒有找到，則丟擲 java.lang.AbstractMethodError 異常

單分派與多分派

方法的接收者與方法的引數統稱為方法的宗量。例子：

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

在這個例子中，有兩個分派過程。一個是編譯階段編譯器的選擇過程，也就是靜態分派的過程，此時選擇目標方法的依據有兩點：物件的靜態型別、方法引數的型別，因此是靜態多分派。而執行階段虛擬機器的選擇過程，也就是動態分派的過程，此時選擇目標方法的依據只有一個：物件的實際型別，因此是動態單分派。

因此，今天的 Java 是一門靜態多分派，動態單分派的語言。

虛擬機器動態分派的實現

由於動態分派是非常頻繁的動作，因此基於效能的考慮，大部分虛擬機器實現都會進行優化，最常用的是穩定優化，為類在方法區中簡歷一個虛方法表（與此對應的，invokeinterface 執行時也會用到介面方法表），使用虛方法表來代替元資料查詢以提高效能。虛方法表結構如圖：

虛擬機器位元組碼執行引擎

虛擬機器除了使用方法表之外，在條件允許的情況下，還會使用內聯快取和基於型別繼承關係分析技術的守護內聯兩種非穩定的激進優化手段來獲得高效能。

動態型別語言支援

Java 虛擬機器的位元組碼指令集數量從 Sun 釋出第一款 Java 虛擬機器到 JDK 7 之間，一直沒發生任何變化，直到 JDK 7，位元組碼指令集終於迎來了第一位新成員——invokedynamic，這條指令的增加是 JDK 7 實現動態型別語言支援而進行的改進之一，也是為 JDK 8 可以順利實現 Lambda 表示式做技術準備。

動態型別語言的關鍵特徵是它的型別檢查的主體過程是在執行期，而不是編譯期。

Java 虛擬機器的願景之一是支援 Java 以外如 Groovy 這樣的動態型別語言，JDK 1.7 以前也能實現類似的效果，但會帶來額外的效能或記憶體開銷，因此在 Java 虛擬機器層面上提供動態型別的語言的直接支援就成為了 Java 語言平臺的發展趨勢之一。

JDK 1.7 加入了 java.lang.invoke 包，這個包的目的是在之前單純依靠符號引用來確定呼叫的目標方法這種方式以外，提供一種新的動態確定目標方法的機制，稱為 MethodHandle。例子：

/**
* JSR 292 MethodHandle基礎用法演示
* @author zzm
*/
public class MethodHandleTest {

    static class ClassA {
        public void println(String s) {
            System.out.println("ClassA: " + s);
        }
    }

    public static void main(String[] args) throws Throwable {
        Object obj = System.currentTimeMillis() % 2 == 0 ? System.out : new ClassA();
        // 無論obj最終是哪個實現類，下面這句都能正確呼叫到println方法。
        getPrintlnMH(obj).invokeExact("icyfenix");
    }

    private static MethodHandle getPrintlnMH(Object reveiver) throws Throwable {
        // MethodType：代表“方法型別”，包含了方法的返回值和具體引數
        MethodType mt = MethodType.methodType(void.class, String.class);
        // lookup()方法來自於 MethodHandles.lookup
        // 作用是在指定類中查詢符合給定的方法名稱、方法型別，並且符合呼叫許可權的方法控制代碼
        // 因為這裡呼叫的是一個虛方法，方法第一個引數是隱式的，代表該方法的接收者 - this
        // this 這個引數以前是放在引數列表中進行傳遞，現在提供了 bindTo() 方法來完成這件事情
        return lookup().findVirtual(reveiver.getClass(), "println", mt).bindTo(reveiver);
    }

}

雖然用反射也能實現相同的效果，但 MethodHandle 和反射還是有區別的：

1) Reflection 是模仿 Java 程式碼層次的方法呼叫，MethodHandle 則是在模擬位元組碼層次的方法呼叫，MethodHandle.lookup 中的 3 個方法 findStatic、findVirtual、findSpecial 對應於 invokestatic、invokevirtual & invokeinterface、invokespecial 這幾條位元組碼指令。

2) Reflection 中的 java.lang.reflect.Method 物件遠比 MethodHandle 機制中的 java.lang.invoke.MethodHandle 物件所包含的資訊多

3) 由於 MethodHandle 是對位元組碼的方法指令呼叫的模擬，所以虛擬機器在這方面做的各種優化，理論上 MethodHandle 也可以採用類似的思路去支援（目前還不完善），而通過反射去呼叫方法則不行

4) 最關鍵的是，Reflection API 是為 Java 語言服務的，而 MethodHandle 則可服務於所有 Java 虛擬機器之上的語言

invokedynamic 指令與 MethodHandle 機制的作用是一樣的，都是為了解決 invoke 指令方法分派規則固化在虛擬機器之中的問題，把如何查詢目標方法的決定權從虛擬機器轉嫁到使用者程式碼之中，讓使用者有更高的自由度。invokedynamic 的第一個引數是 CONSTANT_InvokeDynamic_info 常量，從這個常量可以得到 3 項資訊：引導方法（Bootstrap Method）、方法型別（MethodType）和名稱。引導方法有固定的引數，返回值是 java.lang.invoke.CallSite 物件，這個代表真正要執行的目標方法呼叫。例子：

public class InvokeDynamicTest {

    public static void main(String[] args) throws Throwable {
        INDY_BootstrapMethod().invokeExact("icyfenix");
    }

    public static void testMethod(String s) {
        System.out.println("hello String: " + s);
    }

    // 生成 testMethod
    public static CallSite BootstrapMethod(MethodHandles.Lookup lookup, String name, MethodType mt) throws Throwable {
        return new ConstantCallSite(lookup.findStatic(InvokeDynamicTest.class, name, mt));
    }

    // 生成 BootstrapMethod 對應的 MethodType
    private static MethodType MT_BootstrapMethod() {
        return MethodType
                .fromMethodDescriptorString(
                        "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;)" +
                                "Ljava/lang/invoke/CallSite;",
                        null);
    }

    // 生成 BootstrapMethod
    private static MethodHandle MH_BootstrapMethod() throws Throwable {
        return lookup().findStatic(InvokeDynamicTest.class, "BootstrapMethod", MT_BootstrapMethod());
    }

    // 呼叫 testMethod
    private static MethodHandle INDY_BootstrapMethod() throws Throwable {
        CallSite cs = (CallSite) MH_BootstrapMethod().invokeWithArguments(lookup(), "testMethod",
                MethodType.fromMethodDescriptorString("(Ljava/lang/String;)V", null));
        return cs.dynamicInvoker();
    }
}

invokedynamic 與其它 4 條 invoke 指令最大的差別是它的分派邏輯不由虛擬機器決定，而是由程式設計師決定。

相關推薦

深入理解 Java 虛擬機器（九）方法呼叫

方法呼叫 方法呼叫不等同於方法執行，方法呼叫階段唯一任務就是確定被呼叫方法的版本（即呼叫哪一個方法），暫時還不涉及方法內部的具體執行過程。一切方法呼叫在 Class 檔案裡面儲存的都只是符號引用，需要在類載入期間，甚至到執行期間才能確定目標方法的直接引用。

深入理解java虛擬機器（六）位元組碼指令簡介

Java虛擬機器指令是由（佔用一個位元組長度、代表某種特定操作含義的數字）操作碼Opcode，以及跟隨在其後的零至多個代表此操作所需引數的稱為運算元 Operands 構成的。由於Java虛擬機器是面向運算元棧而不是暫存器的架構，所以大多數指令都只有操作碼，而沒有運算元。 位元組碼指令集是一種具有鮮明特點、

深入理解java虛擬機器（一）java虛擬機器的記憶體區域

一、 java虛擬機器記憶體區域主要有:方法區、堆、虛擬機器棧、本地方方法棧、程式計數器     按照執行緒私有和共有來分：執行緒私有的有--程式計數器，虛擬機器棧，本地方法棧。共有的有--本地方法區，堆     1、程式計數器：主要功能是控制程式

深入理解Java虛擬機器（5）Java記憶體模型

深入理解Java虛擬機器（5）Java記憶體模型 Java記憶體模型 主記憶體和工作記憶體 volatile關鍵字 long與double型別的特殊規則 synchronized關鍵字 Java記憶體模

深入理解java虛擬機器（一）java的記憶體區域

程式計數器：可以看作當前執行緒所執行的位元組碼的行號指示器，位元組碼直譯器工作時就是通過改變這個計數器的值來選取下一條 需要執行的位元組碼指令，分支、迴圈、跳轉、異常處理、執行緒恢復等基礎功能都需要依賴這個計數器來實現。每一個執行緒都有一個獨立的程式計數器，各個執行緒之間的計數器互不影響，獨立

深入理解Java虛擬機器（一）--- Java 與 JVM

Java 特性 1.結構嚴謹，面向物件程式語言 2.跨平臺性 3.較安全的記憶體管理和訪問機制（避免了絕大部分記憶體洩漏和指標越界的問題） 4.實現熱點程式碼檢測和執行時編譯優化 5.擁有一套完整的API介面 6.擁有豐富的第三方庫 JVM 特性 基於棧

深入理解Java虛擬機器（一）——JVM整體結構與垃圾回收演算法介紹

JVM整體架構 •JVM(虛擬機器)：指以軟體的方式模擬具有完整硬體系統功能、執行在一個完全隔離環境中的完整計算機系統 ，是物理機的軟體實現。常用的虛擬機器有VMWare，Virtual Box，Ja

深入理解Java虛擬機器（二）——類載入器深入解析

類載入過程 •類載入：類載入器將class檔案載入到虛擬機器的記憶體  •載入：在硬碟上查詢並通過IO讀入位元組碼檔案 •連線：執行校驗、準備、解析（可選）步驟 •校驗：校驗位元組碼檔案的正確性

深入理解Java虛擬機器（四）——JVM效能調優監控工具

Jinfo 檢視正在執行的Java應用程式的擴充套件引數 檢視jvm的引數 檢視java系統引數 Jstat jstat命令可以檢視堆記憶體各部分的使用量，以及載入類的數量。命

深入理解java虛擬機器（一）

前言  本篇主要講述java記憶體區域的劃分。下面直接進入正題。 概述 java虛擬機器就是在真實物理機上虛擬出來的一臺計算機，java語言有一個特點就是可以跨平臺，其中java起著關鍵作用。這是因為它遮蔽與平臺相關的資訊,java原始檔經過編譯程式編譯後生成位元組碼檔

深入理解java虛擬機器（二）

前言 上篇已經介紹到記憶體結構劃分《深入理解java虛擬機器一》，本篇將介紹jvm記憶體分配。 正文 這裡主要介紹物件記憶體的分配，而物件是在堆中分配記憶體的，堆可以分為新年代和老年代，其中新年代可以劃分為Eden區和Survivor區，而Survivor又可以進一步劃

深入理解java虛擬機器（三）

前言  上篇已經介紹到記憶體結構劃分《深入理解java虛擬機器二》本篇主要講述JVM垃圾回收機制。下面直接進入正題。 正文 JVM垃圾回收機制收集的是死亡的物件，也是就是沒有任何引用的物件。那怎麼判斷物件是否死亡。 引數計數演算法 引數計數演算法會給每個物件新增一個

深入理解java虛擬機器（三）（一個類載入器只初始化一次類物件,不同類載入器可以對同一類物件進行初始化）

package com.ygl; class Final{public static final int x=6/3;//此處x在編譯時能計算出值，是編譯時的常量，則System.out.println(Final.x);直接輸出值，不再執行下面static（前提是fina

深入理解java虛擬機器（一）----jvm記憶體模型

最近大致的學習了一下jvm的相關技術，發現深入理解java虛擬機器這本書很不錯，所以想將這本書的內容的重難點在blog總結一下，一是為了鞏固這些知識，二是為了把這些重點單獨寫出來，讓初學者在學習的時候有一個大致的框架以至於學起來不至於那麼迷茫 學習java虛擬

深入理解Java虛擬機器（0）——JVM基本介紹

1、什麼是JVM？     我們知道Java程式碼可以一次編寫，到處執行（Write once，run anywhere），而這一特性正是JVM提供的。JVM幫工程師遮蔽了不同平臺的差異性，提供了一致的編寫介面。     我們編寫的程式碼首先被編譯器 編譯成 符合

深入理解java虛擬機器（十三） Java 即時編譯器JIT機制以及編譯優化

在部分的商用虛擬機器中，Java 程式最初是通過直譯器（ Interpreter ）進行解釋執行的，當虛擬機發現某個方法或程式碼塊的執行特別頻繁的時候，就會把這些程式碼認定為“熱點程式碼”。為了提高熱點程式碼的執行效率，在執行時，即時編譯器（Just In Time Com

深入理解java虛擬機器（一）：java記憶體區域（記憶體結構劃分）

圖一：java記憶體結構劃分 由上圖可知，java記憶體主要分為6部分，分別是程式計數器，虛擬機器棧，本地方法棧，堆，方法區和直接記憶體,下面將逐一詳細描述。 1、程式計數器 執行緒私有，即每個執行緒都會有一個，執行緒之間互不影響，獨立儲存。 代表著當前執行緒所執行

深入理解JAVA虛擬機器（四）：虛擬機器類載入機制

虛擬機器把描述類的資料從Class檔案載入到記憶體，並對資料進行校驗、轉換解析和初始化，最終形成可以被虛擬機器直接使用的Java型別，這就是虛擬機器的類載入機制。在Java語言裡面，型別的載入、連線和初始化過程都是在程式執行期間完成的。 1、類載入的時機 類從被載入到虛擬機

深入理解Java虛擬機器----（七）位元組碼執行引擎

    位元組碼執行引擎是執行引擎是最重要的一部分，概念模型的總體外觀是一致的：輸入位元組碼，過程是位元組碼解析的等效過程，輸出結果。不同的虛擬機器有不同的具體實現，大體有解釋執行和編譯執行兩種選擇。 執行時棧幀結構：     棧楨在虛擬機器棧中，是支援方法呼叫和執行的結

深入理解java虛擬機器（七）類載入的時機

Class 檔案中描述的各種資訊都必須載入到虛擬機器中才能執行和使用。而虛擬機器怎麼載入這些Class 檔案呢？Class 檔案進入到虛擬機器中會發生什麼變化呢？ 虛擬機器類載入機制是指 虛擬機器把描述類的資料從 Class 檔案載入到記憶體中，並對資料進行校驗、轉換解析、