Java真的是長盛不衰，擁有頑強(qiáng)的生命力。其中，字節(jié)碼機(jī)制功不可沒。字節(jié)碼，就像是 Linux 的 ELF。有了它，JVM直接搖身一變，變成了類似操作系統(tǒng)的東西。

要學(xué)習(xí)字節(jié)碼，不能僅僅靠看枯燥的文檔。本文會介紹幾個有用的工具，可以非常容易的上手，來實際觀測class文件這個小魔獸，助你搲的更深一些。

1、字節(jié)碼結(jié)構(gòu)

1.1、基本結(jié)構(gòu)

在開始之前，我們先簡要的介紹一下class文件的內(nèi)容。這個結(jié)構(gòu)，可以使用jclasslib工具來查看。

上圖是class文件基本內(nèi)容。這部分內(nèi)容枯燥乏味，關(guān)于它的細(xì)節(jié)在Java的官方都能非常容易的找到。

如下圖，展示了一個簡單方法的字節(jié)碼描述，我們可以看到真正的執(zhí)行指令在整個文件結(jié)構(gòu)中的具體位置。

1.2、實際觀測

為了讓大家避免避免枯燥的二進(jìn)制對比分析，直接定位到真正的數(shù)據(jù)結(jié)構(gòu)，這里介紹一個小工具，使用這種方式學(xué)習(xí)字節(jié)碼會節(jié)省很多時間。

https://wiki.openjdk.java.net/display/CodeTools/asmtools

這個工具就是asmtools，執(zhí)行下面的命令，將看到類的 JCED 語法結(jié)果。

java -jar asmtools-7.0.jar jdec LambdaDemo.class

輸出的結(jié)果類似于下面的結(jié)構(gòu)，它與我們上面介紹的字節(jié)碼組成是一一對應(yīng)的，對照官網(wǎng)或者書籍，學(xué)習(xí)速度飛快。

class LambdaDemo {
  0xCAFEBABE;
  0; // minor version
  52; // version
  [] { // Constant Pool
    ; // first element is empty
    Method #8 #25; // #1
    InvokeDynamic 0s #30; // #2
    InterfaceMethod #31 #32; // #3
    Field #33 #34; // #4
    String #35; // #5
    Method #36 #37; // #6
    class #38; // #7
    class #39; // #8
    Utf8 "<init>"; // #9
    Utf8 "()V"; // #10
    Utf8 "Code"; // #11

了解了類的文件組織方式，下面我們來看一下，類文件在加載到內(nèi)存中以后，是一個什么表現(xiàn)形式。

2、內(nèi)存表示

準(zhǔn)備以下代碼，使用javac -g InvokeDemo.java進(jìn)行編譯。然后使用java命令執(zhí)行。程序?qū)⒆枞趕leep函數(shù)上，我們來看一下它的內(nèi)存分布。

interface I {
    default void infMethod() { }

    void inf();
}

abstract class Abs {
    abstract void abs();
}

public class InvokeDemo extends Abs implements I {


    static void staticMethod() { }

    private void privateMethod() { }

    public void publicMethod() { }

    @Override
    public void inf() { }

    @Override
    void abs() { }

    public static void main(String[] args) throws Exception{
        InvokeDemo demo = new InvokeDemo();

        InvokeDemo.staticMethod();
        demo.abs();
        ((Abs) demo).abs();
        demo.inf();
        ((I) demo).inf();
        demo.privateMethod();
        demo.publicMethod();
        demo.infMethod();
        ((I) demo).infMethod();


        Thread.sleep(Integer.MAX_VALUE);
    }
}

為了更加明顯的看到這個過程，下面介紹一下 jhsdb 這個工具，這是在 Java9 之后 JDK 先加入的調(diào)試工具，我們可以在命令行使用 jhsdb hsdb 來啟動它。注意，要加載相應(yīng)的進(jìn)程時，必須確保是同一個版本的應(yīng)用進(jìn)程，否則會產(chǎn)生報錯。

attach啟動后的Java進(jìn)程后，可以在 Class Browser 菜單查看加載的所有類信息。我們在搜索框輸入 InvokeDemo，找到要查看的類。

@符號后面的，就是具體的內(nèi)存地址，我們可以復(fù)制一個，然后在Inspector 視圖查看具體的屬性?？梢源篌w認(rèn)為這就是類在方法區(qū)的具體存儲。

在Inspector視圖中，我們找到方法相關(guān)的屬性 _methods，可惜的是它無法點(diǎn)開，也無法查看。

接下來可以使用命令行來檢查這個數(shù)組里面的值。打開菜單中Console，然后輸入examine命令?？梢钥吹竭@個數(shù)組里的內(nèi)容，對應(yīng)的地址就是Class視圖中的方法地址。

examine 0x000000010e650570/10

我們可以在Inspect視圖看到方法所對應(yīng)的內(nèi)存信息，這確實是一個Method方法的表示。

相比較起來，對象就簡單的，它只需要保存一個到達(dá)Class對象的指針即可。我們需要先從對象視圖進(jìn)入，然后找到它，一步步進(jìn)入Inspect視圖。

由以上的這些分析，我們可以得出下面這張圖。執(zhí)行引擎想要運(yùn)行某個對象的方法，需要先在棧上找到這個對象的引用，然后再通過的對象的指針，找到相應(yīng)的方法字節(jié)碼。

3、方法調(diào)用指令

關(guān)于方法的調(diào)用，Java一共提供了5個指令，用來調(diào)用不同類型的函數(shù)。

1. invokestatic 
2. invokevirtual 
3. invokeinterface 和上面這條指令類似，不過是作用于接口類。
4. invokespecial 用于調(diào)用私有實例方法、構(gòu)造器，以及super關(guān)鍵字等。
5. invokedynamic 用于調(diào)用動態(tài)方法。

我們依然使用上面的代碼片段看一下前四個指令的使用場景。代碼中包含一個接口I，一個抽象類Abs，一個實現(xiàn)和繼承了兩者的類InvokeDemo。

參考Java的類加載機(jī)制，在class文件被加載到方法區(qū)以后，就完成了從符號引用到具體地址的轉(zhuǎn)換過程。

我們可以看一下編譯后的main方法字節(jié)碼。尤其需要注意的是對于接口方法的調(diào)用。使用實例對象直接調(diào)用，和強(qiáng)制轉(zhuǎn)化成接口調(diào)用，所調(diào)用的字節(jié)碼指令分別是 invokevirtual 和invokeinterface，它們是不同的。

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #2                  // class InvokeDemo
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: invokestatic  #4                  // Method staticMethod:()V
        11: aload_1
        12: invokevirtual #5                  // Method abs:()V
        15: aload_1
        16: invokevirtual #6                  // Method Abs.abs:()V
        19: aload_1
        20: invokevirtual #7                  // Method inf:()V
        23: aload_1
        24: invokeinterface #8,  1            // InterfaceMethod I.inf:()V
        29: aload_1
        30: invokespecial #9                  // Method privateMethod:()V
        33: aload_1
        34: invokevirtual #10                 // Method publicMethod:()V
        37: aload_1
        38: invokevirtual #11                 // Method infMethod:()V
        41: aload_1
        42: invokeinterface #12,  1           // InterfaceMethod I.infMethod:()V
        47: return

另外還有一點(diǎn)，和我們想象中的不同，大多數(shù)普通方法調(diào)用，使用的是 invokevirtual 指令，它其實是和invokeinterface 一類的，都屬于虛方法調(diào)用。很多時候，JVM需要根據(jù)調(diào)用者的動態(tài)類型，來確定調(diào)用的目標(biāo)方法，這就是動態(tài)綁定的過程。

invokevirtual指令有多態(tài)查找的機(jī)制，該指令的運(yùn)行時解析過程步驟如下：

1. 找到操作數(shù)棧頂?shù)牡谝粋€元素所指向的對象的實際類型，記做c。
2. 如果在類型c中找到與常量中的描述符和簡單名稱都相符的方法，則進(jìn)行訪問權(quán)限校驗，如果通過則返回這個方法的直接引用，查找過程結(jié)束，不通過則返回java.lang.IllegalAccessError。
3. 否則，按照繼承關(guān)系從下往上依次對c的各個父類進(jìn)行第二步的搜索和驗證過程。
4. 始終沒找到合適的方法，拋出java.lang.AbstractMethodError異常。這就是java語言中方法重寫的本質(zhì)。

相對比，invokestatic指令，加上invokespecial指令，就屬于靜態(tài)綁定過程。

所以靜態(tài)綁定，指的是能夠直接識別目標(biāo)方法的情況，而動態(tài)綁定指的是需要在運(yùn)行過程中根據(jù)調(diào)用者的類型來確定目標(biāo)方法的情況。

可以想象，相對于靜態(tài)綁定的方法調(diào)用來說，動態(tài)綁定的調(diào)用就更加耗時一些。由于方法的調(diào)用非常的頻繁，JVM對動態(tài)調(diào)用的代碼進(jìn)行了比較多的優(yōu)化。比如使用方法表來加快對具體方法的尋址，以及使用更快的緩沖區(qū)來直接尋址（ 內(nèi)聯(lián)緩存）。

4、invokedynamic

有時候在寫一些python腳本或者js腳本的時候，會特別羨慕這些動態(tài)語言。如果把查找目標(biāo)方法的決定權(quán)，從虛擬機(jī)轉(zhuǎn)嫁給用戶代碼，我們就會有更高的自由度。

我們單獨(dú)把invokedynamic抽離出來介紹，是因為它比較復(fù)雜。和反射類似，它用于一些動態(tài)的調(diào)用場景，但它和反射有著本質(zhì)的不同，效率也比反射要高的多。

這個指令通常在lambda語法中出現(xiàn)，我們來看一下一小段代碼。

public class LambdaDemo {
    public static void main(String[] args) {
        Runnable r = () -> System.out.println("Hello Lambda");
        r.run();
    }
}

使用javap -p -v 命令可以在main方法中看到invokedynamic指令。

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=2, args_size=1
         0: invokedynamic #2,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
         5: astore_1
         6: aload_1
         7: invokeinterface #3,  1            // InterfaceMethod java/lang/Runnable.run:()V
        12: return

另外，我們在javap的輸出中找到了一些奇怪的東西。

BootstrapMethods:
  0: #27 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #28 ()V
      #29 invokestatic LambdaDemo.lambda$main$0:()V
      #28 ()V

BootstrapMethods屬性在Java1.7以后才有，位于類文件的屬性列表中，這個屬性用于保存 invokedynamic 指令引用的引導(dǎo)方法限定符。

和上面介紹的四個指令不同，invokedynamic并沒有確切的接收對象，取而代之的，是一個叫做 CallSite 的對象。

static CallSite bootstrap(MethodHandles.Lookup caller, String name, MethodType type);

其實，invokedynamic指令的底層，是使用方法句柄（MethodHandle）來實現(xiàn)的。方法句柄是一個能夠被執(zhí)行的引用，它可以指向靜態(tài)方法和實例方法，以及虛構(gòu)的get和set方法，從IDE中可以看到這些函數(shù)。

句柄類型（MethodType）就是我們對方法的具體描述，配合方法名稱，能夠定位到一類函數(shù)。訪問方法句柄和調(diào)用原來的指令是基本一致的，但它的調(diào)用異常，包括一些權(quán)限檢查，是在運(yùn)行時才能被發(fā)現(xiàn)的。

lambda語言實際上是通過方法句柄來完成的，在調(diào)用鏈上自然也多了一些調(diào)用步驟，那么在性能上，是否就意味著lambda性能低呢？對于大部分“非捕獲”的lambda表達(dá)式來說，JIT編譯器的逃逸分析能夠優(yōu)化這部分差異，性能和傳統(tǒng)方式無異；但對于“捕獲型”的表達(dá)式來說，就需要通過方法句柄，不斷的生成適配器，性能自然就低了很多（不過和便捷性相比，一丁點(diǎn)性能損失是可接受的）。

除了lambda表達(dá)式，我們還沒有其他的方式來產(chǎn)生invokedynamic指令。但是我們可以使用一些外部的字節(jié)碼修改工具，比如ASM，來生成一些帶有這個指令的字節(jié)碼，這通常能夠完成一些非?？岬墓δ?，比如完成一門弱類型檢查的JVM-Base語言。

END

本文從Java字節(jié)碼的頂層結(jié)構(gòu)介紹開始，通過一個實際代碼，了解了類加載以后，在JVM內(nèi)存里的表現(xiàn)形式，并了解了jhsdb對Java進(jìn)程的觀測方式。

我們了解到Java7之后的invokedynamic指令，它實際上是通過方法句柄來實現(xiàn)的。和我們關(guān)系最大的就是Lambda語法，了解了這些原理，可以忽略那些對Lambda性能高低的爭論，要盡量寫一些“非捕獲”的Lambda表達(dá)式。

什么？你問什么叫非捕獲？那就需要你自己搲了。

 作者簡介：小姐姐味道  (xjjdog)，一個不允許程序員走彎路的公眾號。聚焦基礎(chǔ)架構(gòu)和Linux。十年架構(gòu)，日百億流量，與你探討高并發(fā)世界，給你不一樣的味道。