国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Java虛擬機 :Java字節碼指令的執行

coolpail / 2110人閱讀

摘要:虛擬機執行程序的基礎是特定的二進制指令集和運行時棧幀二進制指令集是虛擬機規定的一些指令,在編譯后二進制字節碼的類方法里的字節碼就是這種指令,所以只要找到方法區里的類方法就可以依照這套指令集去執行命令。

這篇文章的素材來自周志明的《深入理解Java虛擬機》。

作為Java開發人員,一定程度了解JVM虛擬機的的運作方式非常重要,本文就一些簡單的虛擬機的相關概念和運作機制展開我自己的學習過程,是這個系列的第三篇。

虛擬機運行活化的內存數據中的指令:程序的執行

前面我們說明了java源碼被編譯成為了二進制字節碼,二進制字節碼轉為內存中方法區里存儲的活化對象,那么最重要的程序執行就做好了基礎:當方法區里的字段和方法按照虛擬機規定的數據結構排好,常量池中的符號引用數據在加載過程中最大限度地轉為了直接引用,那么這個時候虛擬機就可以在加載主類后創建新的線程按步執行主類的main函數中的指令了。

java虛擬機執行程序的基礎是特定的二進制指令集和運行時棧幀:

二進制指令集是java虛擬機規定的一些指令,在編譯后二進制字節碼的類方法里的字節碼就是這種指令,所以只要找到方法區里的類方法就可以依照這套指令集去執行命令。

運行時棧幀是虛擬機執行的物理所在,在這個棧幀結構上,方法的局部變量、操作數棧、動態鏈接和返回地址依序排列,依照命令動態變換棧幀上的數據,最終完成所有的這個方法上的指令。

棧幀的進一步劃分:

局部變量表:包括方法的參數和方法體內部的局部變量都會存在這個表中。

操作數棧:操作數棧是一個運行中間產生的操作數構成的棧,這個棧的棧頂保存的就是當前活躍的操作數。

動態鏈接:我們之前提到這個方法中調用的方法和類在常量池中的符號引用轉換為的直接引用就保存在這里,只要訪問到這些方法和類的時候就會根據動態鏈接去直接引用所指的地址加載那些方法。

返回地址:程序正常結束恢復上一個棧幀的狀態的時候需要知道上一個指令的地址。

現在我們使用一個綜合實例來說明運行的整個過程:

源代碼如下,邏輯很簡單:

public class TestDemo {
    public static int minus(int x){
        return -x;
    }
    public static void main(String[] args) {
        int x = 5;
        int y = minus(x);
    }
}

我們可以分析它的二進制字節碼,當然這里我們借助javap工具進行分析:

jinhaoplus$ javap -verbose TestDemo
Classfile /Users/jinhao/Desktop/TestDemo.class
  Last modified 2015-10-17; size 342 bytes
  MD5 checksum 4f37459aa1b3438b1608de788d43586d
  Compiled from "TestDemo.java"
public class TestDemo
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#15         // java/lang/Object."":()V
   #2 = Methodref          #3.#16         // TestDemo.minus:(I)I
   #3 = Class              #17            // TestDemo
   #4 = Class              #18            // java/lang/Object
   #5 = Utf8               
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Utf8               LineNumberTable
   #9 = Utf8               minus
  #10 = Utf8               (I)I
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               TestDemo.java
  #15 = NameAndType        #5:#6          // "":()V
  #16 = NameAndType        #9:#10         // minus:(I)I
  #17 = Utf8               TestDemo
  #18 = Utf8               java/lang/Object
{
  public TestDemo();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."":()V
         4: return
      LineNumberTable:
        line 1: 0

  public static int minus(int);
    descriptor: (I)I
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=1, args_size=1
         0: iload_0
         1: ineg
         2: ireturn
      LineNumberTable:
        line 3: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=3, args_size=1
         0: iconst_5
         1: istore_1
         2: iload_1
         3: invokestatic  #2                  // Method minus:(I)I
         6: istore_2
         7: return
      LineNumberTable:
        line 6: 0
        line 7: 2
        line 8: 7
}
SourceFile: "TestDemo.java"

這個過程是從固化在class文件中的二進制字節碼開始,經過加載器對當前類的加載,虛擬機對二進制碼的驗證、準備和一定的解析,進入內存中的方法區,常量池中的符號引用一定程度上轉換為直接引用,使得字節碼通過結構化的組織讓虛擬機了解類的每一塊的構成,創建的線程申請到了虛擬機棧中的空間構造出屬于這一線程的棧幀空間,執行主類的main方法:

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=3, args_size=1
         0: iconst_5
         1: istore_1
         2: iload_1
         3: invokestatic  #2                  // Method minus:(I)I
         6: istore_2
         7: return
      LineNumberTable:
        line 6: 0
        line 7: 2
        line 8: 7
}

首先檢查main的訪問標志、描述符描述的返回類型和參數列表,確定可以訪問后進入Code屬性表執行命令,讀入棧深度建立符合要求的操作數棧,讀入局部變量大小建立符合要求的局部變量表,根據參數數向局部變量表中依序加入參數(第一個參數是引用當前對象的this,所以空參數列表的參數數也是1),然后開始根據命令正式執行:

0: iconst_5

將整數5壓入棧頂

1: istore_1

將棧頂整數值存入局部變量表的slot1(slot0是參數this)

2: iload_1

將slot1壓入棧頂

3: invokestatic  #2   // Method minus:(I)I

二進制invokestatic方法用于調用靜態方法,參數是根據常量池中已經轉換為直接引用的常量,意即minus函數在方法區中的地址,找到這個地址調用函數,向其中加入的參數為棧頂的值

6: istore_2

將棧頂整數存入局部變量的slot2

7: return

將返回地址中存儲的PC地址返到PC,棧幀恢復到調用前

現在我們分析調用minus函數的時候進入minus函數的過程:

public static int minus(int);
    descriptor: (I)I
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=1, args_size=1
         0: iload_0
         1: ineg
         2: ireturn
      LineNumberTable:
        line 3: 0

同樣的首先檢查minus函數的訪問標志、描述符描述的返回類型和參數列表,確定可以訪問后進入Code屬性表執行命令,讀入棧深度建立符合要求的操作數棧,讀入局部變量大小建立符合要求的局部變量表,根據參數數向局部變量表中依序加入參數,然后開始根據命令正式執行:

0: iload_0

將slot0壓入棧頂,也就是傳入的參數

1: ineg

將棧頂的值彈出取負后壓回棧頂

2: ireturn

將返回地址中存儲的PC地址返到PC,棧幀恢復到調用前

這個過程結束后對象的生命周期結束,因此開始執行GC回收內存中的對象,包括堆中的類對應的java.lang.Class對象,卸載方法區中的類。

方法的解析和分派

上面這個例子中main方法里調用minus方法的時候是沒有二義性的,因為從二進制字節碼里我們可以看到invokestatic方法調用的是minus方法的直接引用,也就說在編譯期這個調用就已經決定了。這個時候我們來說說方法調用,這個部分的內容在前面的類加載時候提過,在能夠唯一確定方法的直接引用的時候虛擬機會將常量表里的符號引用轉換為直接引用,這樣在運行的時候就可以直接根據這個地址找到對應的方法去執行,這種時候的轉換才能叫做我們當時提到的在連接過程中的解析。
但是如果方法是動態綁定的,也就是說在編譯期我們并不知道使用哪個方法(或者叫不知道使用方法的哪個版本),那么這個時候就需要在運行時才能確定哪個版本的方法將被調用,這個時候才能將符號引用轉換為直接引用。這個問題提到的多個版本的方法在java中的重載和多態重寫問題息息相關。

重載(override)

public class TestDemo {
    static class Human{
    }
    static class Man extends Human{

    }
    static class Woman extends Human{

    }
    public void sayHello(Human human) {
        System.out.println("hello human");
    }
    public void sayHello(Man man) {
        System.out.println("hello man");
    }
    public void sayHello(Woman woman) {
        System.out.println("hello woman");
    }
    public static void main(String[] args) {
        TestDemo demo = new TestDemo();
        Human man = new Man();
        Human woman = new Woman();
        demo.sayHello(man);
        demo.sayHello(woman);
    }
}

javap結果:

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: new           #7                  // class TestDemo
         3: dup
         4: invokespecial #8                  // Method "":()V
         7: astore_1
         8: new           #9                  // class TestDemo$Man
        11: dup
        12: invokespecial #10                 // Method TestDemo$Man."":()V
        15: astore_2
        16: new           #11                 // class TestDemo$Woman
        19: dup
        20: invokespecial #12                 // Method TestDemo$Woman."":()V
        23: astore_3
        24: aload_1
        25: aload_2
        26: invokevirtual #13                 // Method sayHello:(LTestDemo$Human;)V
        29: aload_1
        30: aload_3
        31: invokevirtual #13                 // Method sayHello:(LTestDemo$Human;)V
        34: return
      LineNumberTable:
        line 21: 0
        line 22: 8
        line 23: 16
        line 24: 24
        line 25: 29
        line 26: 34

重寫(overwrite)

public class TestDemo {
    static class Human{
        public void sayHello() {
            System.out.println("hello human");
        }
    }
    static class Man extends Human{
        public void sayHello() {
            System.out.println("hello man");
        }
    }
    static class Woman extends Human{
        public void sayHello() {
            System.out.println("hello woman");
        }
    }

    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();
        man.sayHello();
        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 TestDemo$Man
         3: dup
         4: invokespecial #3                  // Method TestDemo$Man."":()V
         7: astore_1
         8: new           #4                  // class TestDemo$Woman
        11: dup
        12: invokespecial #5                  // Method TestDemo$Woman."":()V
        15: astore_2
        16: aload_1
        17: invokevirtual #6                  // Method TestDemo$Human.sayHello:()V
        20: aload_2
        21: invokevirtual #6                  // Method TestDemo$Human.sayHello:()V
        24: return
      LineNumberTable:
        line 20: 0
        line 21: 8
        line 22: 16
        line 23: 20
        line 24: 24

我們可以看出來無論是重載還是重寫,都是二進制指令invokevirtual調用了sayHello方法來執行的。

在重載中,程序調用的是參數實際類型不同的方法,但是虛擬機最終分派了相同外觀類型(靜態類型)的方法,這說明在重載的過程中虛擬機在運行的時候是只看參數的外觀類型(靜態類型)的,而這個外觀類型(靜態類型)是在編譯的時候就已經確定的,和虛擬機沒有關系。這種依賴靜態類型來做方法的分配叫做靜態分派。

在重寫中,程序調用的是不同實際類型的同名方法,虛擬機依據對象的實際類型去尋找是否有這個方法,如果有就執行,如果沒有去父類里找,最終在實際類型里找到了這個方法,所以最終是在運行期動態分派了方法。在編譯的時候我們可以看到字節碼指示的方法都是一樣的符號引用,但是運行期虛擬機能夠根據實際類型去確定出真正需要的直接引用。這種依賴實際類型來做方法的分配叫做動態分派。得益于java虛擬機的動態分派會在分派前確定對象的實際類型,面向對象的多態性才能體現出來。

對象的創建和堆內存的分配

前面我們提到的都是類在方法區中的內存分配:

在方法區中有類的常量池,常量池中保存著類的很多信息的符號引用,很多符號引用還轉換為了直接引用以使在運行的過程能夠訪問到這些信息的真實地址。

那么創建出的對象是怎么在堆中分配空間的呢?

首先我們要明確對象中存儲的大部分的數據就是它對應的非靜態字段和每個字段方法對應的方法區中的地址,因為這些東西每個對象都是不一樣的,所以必須通過各自的堆空間存儲這些不一樣的數據,而方法是所有同類對象共用的,因為方法的命令是一樣的,每個對象只是在各自的線程棧幀里提供各自的局部變量表和操作數棧就好。

這樣看來,堆中存放的是真正“有個性”的屬于對象自己的變量,這些變量往往是最占空間的,而這些變量對應的類字段的地址會找到位于方法區中,同樣的同類對象如果要執行一個方法只需要在自己的棧幀里面創建局部變量表和操作數棧,然后根據方法對應的方法區中的地址去尋找到方法體執行其中的命令即可,這樣一來堆里面只存放有限的真正有意義的數據和地址,方法區里存放共用的字段和方法體,能最大程度地減小內存開銷。

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/64695.html

相關文章

  • JVM虛擬詳解

    摘要:虛擬機包括一套字節碼指令集一組寄存器一個棧一個垃圾回收堆和一個存儲方法域。而使用虛擬機是實現這一特點的關鍵。虛擬機在執行字節碼時,把字節碼解釋成具體平臺上的機器指令執行。此內存區域是唯一一個在虛擬機規范中沒有規定任何情況的區域。 1、 什么是JVM?   JVM是Java Virtual Machine(Java虛擬機)的縮寫,JVM是一種用于計算設備的規范,它是一個虛構出來的計算機,...

    rottengeek 評論0 收藏0
  • 教你用Java字節做點有趣

    摘要:字節碼是程序的中間表示形式介于人類可讀的源碼和機器碼之間。在中一般是用編譯源文件變成字節碼,也就是我們的文件。字節碼的執行操作,指的就是對當前棧幀數據結構進行的操作。 0.寫在前面 為什么會寫這篇文章呢?主要是之前調研過日志脫敏相關的一些,具體可以參考LOG4j脫敏插件如何編寫里面描述了日志脫敏插件編寫方法: 直接在toString中修改代碼,這種方法很麻煩,效率低,需要修改每一個要...

    hqman 評論0 收藏0
  • 深入理解Java虛擬到底是什么

    摘要:由虛擬機加載的類,被加載到虛擬機內存中之后,虛擬機會讀取并執行它里面存在的字節碼指令。虛擬機中執行字節碼指令的部分叫做執行引擎。 什么是Java虛擬機? 作為一個Java程序員,我們每天都在寫Java代碼,我們寫的代碼都是在一個叫做Java虛擬機的東西上執行的。但是如果要問什么是虛擬機,恐怕很多人就會模棱兩可了。在本文中,我會寫下我對虛擬機的理解。因為能力所限,可能有些地方描述的不夠欠...

    宋華 評論0 收藏0
  • 字節及ASM使用

    摘要:字節碼及使用什么是字節碼機器碼機器碼是可直接解讀的指令。字節碼的執行操作,指的就是對當前棧幀數據結構進行的操作。動態鏈接每個棧幀指向運行時常量池中該棧幀所屬的方法的引用,也就是字節碼的發放調用的引用。 字節碼及ASM使用 什么是字節碼? 機器碼機器碼(machine code)是CPU可直接解讀的指令。機器碼與硬件等有關,不同的CPU架構支持的硬件碼也不相同。 字節碼字節碼(byte...

    hearaway 評論0 收藏0
  • Java如何運行在Java虛擬

    摘要:我們都知道要運行代碼就必須要有,也就是運行時環境,中包含了程序的必需組件,包括虛擬機以及核心類庫,然而運行代碼則不需要額外的運行時環境,只需要把代碼編譯成能識別的指令即可,也就是機器碼那為什么不直接像那樣而需要在虛擬機中運行呢他在虛擬機中又 我們都知道要運行Java代碼就必須要有JRE,也就是Java運行時環境,JRE中包含了Java程序的必需組件,包括Java虛擬機以及Java核心類...

    whjin 評論0 收藏0
  • JAVA 虛擬類加載制和字節執行引擎

    摘要:實現這個口號的就是可以運行在不同平臺上的虛擬機和與平臺無關的字節碼。類加載過程加載加載是類加載的第一個階段,虛擬機要完成以下三個過程通過類的全限定名獲取定義此類的二進制字節流。驗證目的是確保文件字節流信息符合虛擬機的要求。 引言 我們知道java代碼編譯后生成的是字節碼,那虛擬機是如何加載這些class字節碼文件的呢?加載之后又是如何進行方法調用的呢? 一 類文件結構 無關性基石 ja...

    RichardXG 評論0 收藏0

發表評論

0條評論

coolpail

|高級講師

TA的文章

閱讀更多
最新活動
閱讀需要支付1元查看
<