虛擬機器棧概述

由於跨平臺性的設計，Java的指令都是根據棧來設計的。不同平臺CPU架構不同，所以不能設計為基於暫存器的。

優點是跨平臺，指令集小，編譯器容易實現，缺點是效能下降，實現同樣的功能需要更多的指令。

有不少Java開發人員一提到Java記憶體結構，就會非常粗粒度地將JVM中的記憶體區理解為僅有Java堆（heap）和Java戰（stack）？為什麼？

首先棧是執行時的單位，而堆是儲存的單位

• 棧解決程式的執行問題，即程式如何執行，或者說如何處理資料。
• 堆解決的是資料儲存的問題，即資料怎麼放，放哪裡

Java虛擬機器棧是什麼

Java虛擬機器棧（Java Virtual Machine Stack），早期也叫Java棧。每個執行緒在建立時都會建立一個虛擬機器棧

• 是執行緒私有的

生命週期

生命週期和執行緒一致，也就是執行緒結束了，該虛擬機器棧也銷燬了

作用

主管Java程式的執行，它儲存方法的區域性變數（8種基本資料型別、物件的引用地址）、部分結果，並參與方法的呼叫和返回。

• 區域性變數，它是相比於成員變數來說的（或屬性）
• 基本資料型別變數 VS 引用型別變數（類、陣列、介面）

棧的特點

棧是一種快速有效的分配儲存方式，訪問速度僅次於程式計數器。JVM直接對Java棧的操作只有兩個：

• 每個方法執行，伴隨著進棧（入棧、壓棧）
• 執行結束後的出棧
  工作

對於棧來說不存在垃圾回收問題（棧存在溢位的情況）

開發中遇到哪些異常？

棧中可能出現的異常

Java 虛擬機器規範允許Java棧的大小是動態的或者是固定不變的。

• 如果採用固定大小的Java虛擬機器棧，那每一個執行緒的Java虛擬機器棧容量可以線上程建立的時候獨立選定。如果執行緒請求分配的棧容量超過Java虛擬機器棧允許的最大容量，Java虛擬機器將會丟擲一個StackoverflowError 異常。

• 如果Java虛擬機器棧可以動態擴充套件，並且在 嘗試擴充套件的時候無法申請到足夠的記憶體，或者在建立新的執行緒時沒有足夠的記憶體去建立對應的虛擬機器棧，那Java虛擬機器將會丟擲一個OutOfMemoryError

  異常。

設定棧記憶體大小

我們可以使用引數 -Xss選項來設定執行緒的最大棧空間，棧的大小直接決定了函式呼叫的最大可達深度

棧的儲存單位

棧中儲存什麼？

每個執行緒都有自己的棧，棧中的資料都是以棧幀（Stack Frame）的格式存在。

在這個執行緒上正在執行的每個方法都各自對應一個棧幀（Stack Frame）。

棧幀是一個記憶體區塊，是一個數據集，維繫著方法執行過程中的各種資料資訊。

JVM直接對Java棧的操作只有兩個，就是對棧幀的壓棧和出棧，遵循“先進後出”/“後進先出”原則。

在一條活動執行緒中，一個時間點上，只會有一個活動的棧幀。即只有當前正在執行的方法的棧幀（棧頂棧幀）是有效的，這個棧幀被稱為當前棧幀（Current Frame），與當前棧幀相對應的方法就是當前方法（Current Method），定義這個方法的類就是當前類（Current Class）。

執行引擎執行的所有位元組碼指令只針對當前棧幀進行操作。

如果在該方法中呼叫了其他方法，對應的新的棧幀會被創建出來，放在棧的頂端，成為新的當前幀。

例子：

package com.atguigu.java1;

public class StackFrameTest {
    public static void main(String[] args) {
        StackFrameTest stackFrameTest = new StackFrameTest();
        stackFrameTest.method1();
    }

    public void method1() {
        System.out.println("method1()開始執行");
        method2();
        System.out.println("method1()執行結束");
    }

    private int method2() {
        System.out.println("method2()開始執行");
        int i = 10;
        int m = (int) method3();
        System.out.println("method2()即將執行結束");
        return i + m;
    }

    private double method3() {
        System.out.println("method3()開始執行");
        double j = 20.0;
        System.out.println("method3()即將執行結束");
        return j;
    }
}

method1()開始執行
method2()開始執行
method3()開始執行
method3()即將執行結束
method2()即將執行結束
method1()執行結束

Process finished with exit code 0

棧執行原理

不同執行緒中所包含的棧幀是不允許存在相互引用的，即不可能在一個棧幀之中引用另外一個執行緒的棧幀。

如果當前方法呼叫了其他方法，方法返回之際，當前棧幀會傳回此方法的執行結果給前一個棧幀，接著，虛擬機器會丟棄當前棧幀，使得前一個棧幀重新成為當前棧幀。

Java方法有兩種返回函式的方式，一種是正常的函式返回，使用return指令；另外一種是丟擲異常。不管使用哪種方式，都會導致棧幀被彈出。

棧幀的內部結構

每個棧幀中儲存著：

• 區域性變量表（Local Variables）

• 運算元棧（Operand Stack）（或表示式棧）

• 動態連結（Dynamic Linking）（或指向執行時常量池的方法引用）

• 方法返回地址（Return Address）（或方法正常退出或者異常退出的定義）

• 一些附加資訊

並行每個執行緒下的棧都是私有的，因此每個執行緒都有自己各自的棧，並且每個棧裡面都有很多棧幀，棧幀的大小主要由區域性變量表和運算元棧決定的

區域性變量表

區域性變量表：Local Variables，被稱之為區域性變數陣列或本地變量表

定義為一個數字陣列，主要用於儲存方法引數和定義在方法體內的區域性變數這些資料型別包括各類基本資料型別、物件引用（reference），以及returnAddress型別。

由於區域性變量表是建立線上程的棧上，是執行緒的私有資料，因此不存在資料安全問題

區域性變量表所需的容量大小是在編譯期確定下來的，並儲存在方法的Code屬性的maximum local variables資料項中。在方法執行期間是不會改變區域性變量表的大小的。

方法巢狀呼叫的次數由棧的大小決定。一般來說，棧越大，方法巢狀呼叫次數越多。對一個函式而言，它的引數和區域性變數越多，使得區域性變量表膨脹，它的棧幀就越大，以滿足方法呼叫所需傳遞的資訊增大的需求。進而函式呼叫就會佔用更多的棧空間，導致其巢狀呼叫次數就會減少。

區域性變量表中的變數只在當前方法呼叫中有效。在方法執行時，虛擬機器通過使用區域性變量表完成引數值到引數變數列表的傳遞過程。當方法呼叫結束後，隨著方法棧幀的銷燬，區域性變量表也會隨之銷燬。

關於Slot的理解

引數值的存放總是在區域性變數陣列的index0開始，到陣列長度-1的索引結束。

區域性變量表，最基本的儲存單元是Slot（變數槽），區域性變量表中存放編譯期可知的各種基本資料型別（8種），引用型別（reference），returnAddress型別的變數。

在區域性變量表裡，32位以內的型別只佔用一個slot（包括returnAddress型別），64位的型別（1ong和double）佔用兩個slot。

• byte、short、char 在儲存前被轉換為int，boolean也被轉換為int，0表示false，非0表示true。
• long和double則佔據兩個slot。

JVM會為區域性變量表中的每一個Slot都分配一個訪問索引，通過這個索引即可成功訪問到區域性變量表中指定的區域性變數值

當一個例項方法被呼叫的時候，它的方法引數和方法體內部定義的區域性變數將會按照順序被複制到區域性變量表中的每一個slot上

如果需要訪問區域性變量表中一個64bit的區域性變數值時，只需要使用前一個索引即可。（比如：訪問long或double型別變數）

如果當前幀是由構造方法或者例項方法建立的，那麼該物件引用this將會存放在index為0的slot處，其餘的引數按照引數表順序繼續排列。

例子：

package com.atguigu.java1;

import java.util.Date;

public class LocalVariablesTest {
    private int count = 0;

    public static void main(String[] args) {
        LocalVariablesTest localVariablesTest = new LocalVariablesTest();
        int num = 10;
        localVariablesTest.test1();
    }

    public static void testStatic() {
        LocalVariablesTest localVariablesTest = new LocalVariablesTest();
        Date date = new Date();
        int count = 10;
        System.out.println(count);
        // 因為this變數不存在於當前方法的區域性變量表中！！！
        // System.out.println(this.count);
    }

    // 關於slot的使用和理解
    public LocalVariablesTest() {
        this.count = 1;
    }

    public void test1() {
        Date date = new Date();
        String name1 = "atguigu.com";
        String info = test2(date, name1);
        System.out.println(date + name1);
    }

    public String test2(Date dateP, String name2) {
        dateP = null;
        name2 = "songhongkang";
        double weight = 10.5;       // 佔據2個slot
        char gender = '男';
        return dateP + name2;
    }

    public void test3() {
        count++;
    }

    public void test4() {
        int a = 0;
        {
            int b = 0;
            b = a + 1;
        }
        int c = a + 1;
    }
}

Slot的重複利用

棧幀中的區域性變量表中的槽位是可以重用的，如果一個區域性變數過了其作用域，那麼在其作用域之後申明的新的區域性變就很有可能會複用過期區域性變數的槽位，從而達到節省資源的目的。

public void test4() {
  int a = 0;
  {
    int b = 0;
    b = a + 1;
  }
  // 變數c使用之前已經銷燬的變數b佔據的位置
  int c = a + 1;
}

靜態變數與區域性變數的對比

變數的分類：

• 按資料型別分：基本資料型別、引用資料型別
• 按類中宣告的位置分：成員變數（類變數，例項變數）、區域性變數
  • 類變數static：linking的paper階段，給類變數預設賦值（如int型別預設給他賦值為0），init階段給類變數顯示賦值即靜態程式碼塊
  • 例項變數（不是static）：隨著物件建立，會在堆空間中分配例項變數空間，並進行預設賦值（如int型別預設給他賦值為0）
  • 區域性變數：在使用前必須進行顯式賦值，不然編譯不通過。

引數表分配完畢之後，再根據方法體內定義的變數的順序和作用域分配。

我們知道類變量表有兩次初始化的機會，第一次是在“準備階段”，執行系統初始化，對類變數設定零值，另一次則是在“初始化”階段，賦予程式設計師在程式碼中定義的初始值。

和類變數初始化不同的是，區域性變量表不存在系統初始化的過程，這意味著一旦定義了局部變數則必須人為的初始化，否則無法使用。

在棧幀中，與效能調優關係最為密切的部分就是前面提到的區域性變量表。在方法執行時，虛擬機器使用區域性變量表完成方法的傳遞。

區域性變量表中的變數也是重要的垃圾回收根節點，只要被區域性變量表中直接或間接引用的物件都不會被回收。

運算元棧

概念

每一個獨立的棧幀除了包含區域性變量表以外，還包含一個後進先出（Last-In-First-Out）的運算元棧，也可以稱之為表示式棧（Expression Stack）

運算元棧，在方法執行過程中，根據位元組碼指令，往棧中寫入資料或提取資料，即入棧（push）和 出棧（pop）

也就是位元組碼指令的執行過程

• 某些位元組碼指令將值壓入運算元棧，其餘的位元組碼指令將運算元取出棧。使用它們後再把結果壓入棧
• 比如：執行復制、交換、求和等操作

運算元棧，主要用於儲存計算過程的中間結果，同時作為計算過程中變數臨時的儲存空間。

運算元棧就是JVM執行引擎的一個工作區，當一個方法剛開始執行的時候，一個新的棧幀也會隨之被創建出來，這個方法的運算元棧是空的。

這個時候陣列是有長度的，因為陣列一旦建立，那麼就是不可變的

每一個運算元棧都會擁有一個明確的棧深度用於儲存數值，其所需的最大深度在編譯期就定義好了，儲存在方法的Code屬性中，為maxstack的值。

棧中的任何一個元素都是可以任意的Java資料型別

• 32bit的型別佔用一個棧單位深度
• 64bit的型別佔用兩個棧單位深度

運算元棧並非採用訪問索引的方式來進行資料訪問的，而是隻能通過標準的入棧和出棧操作來完成一次資料訪問

如果被呼叫的方法帶有返回值的話，其返回值將會被壓入當前棧幀的運算元棧中，並更新PC暫存器中下一條需要執行的位元組碼指令。（aload_x)

public int getSum() {
     int m = 10;
     int n = 20;
     int k = m + n;
     return k;
 }

public void testGetSum() {
// 獲取上一個棧幀返回的結果，並將其儲存在運算元棧中
int i = getSum();
int j = 10;
}

運算元棧中元素的資料型別必須與位元組碼指令的序列嚴格匹配，這由編譯器在編譯器期間進行驗證，同時在類載入過程中的類檢驗階段的資料流分析階段要再次驗證。

另外，我們說Java虛擬機器的解釋引擎是基於棧的執行引擎，其中的棧指的就是運算元棧。

程式碼追蹤

package com.atguigu.java1;

public class OperandStackTest {
    public void testAddOperation() {
        // byte short char boolean：都以int型儲存
        byte i = 15;
        int j = 8;
        int k = i + j;
    }
}

使用javap 命令反編譯class檔案： javap -v 類名.class

public void testAddOperation();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         0: bipush        15
         2: istore_1
         3: bipush        8
         5: istore_2
         6: iload_1
         7: iload_2
         8: iadd
         9: istore_3
        10: return

棧頂快取技術

前面提過，基於棧式架構的虛擬機器所使用的零地址指令更加緊湊，但完成一項操作的時候必然需要使用更多的入棧和出棧指令，這同時也就意味著將需要更多的指令分派（instruction dispatch）次數和記憶體讀/寫次數。

由於運算元是儲存在記憶體中的，因此頻繁地執行記憶體讀/寫操作必然會影響執行速度。為了解決這個問題，HotSpot JVM的設計者們提出了棧頂快取（Tos，Top-of-Stack Cashing）技術，將棧頂元素全部快取在物理CPU的暫存器中，以此降低對記憶體的讀/寫次數，提升執行引擎的執行效率。

動態連結（指向執行時常量池的方法飲用）

每一個棧幀內部都包含一個指向執行時常量池中該棧幀所屬方法的引用包含這個引用的目的就是為了支援當前方法的程式碼能夠實現動態連結（Dynamic Linking）。比如：invokedynamic指令

在Java原始檔被編譯到位元組碼檔案中時，所有的變數和方法引用都作為符號引用（symbolic Reference）儲存在class檔案的常量池裡。

比如：描述一個方法呼叫了另外的其他方法時，就是通過常量池中指向方法的符號引用來表示的，那麼動態連結的作用就是為了將這些符號引用轉換為呼叫方法的直接引用。

package com.atguigu.java1;

public class DynamicLinkingTest {
    int num = 10;

    public void methodA() {
        System.out.println("methodA.......");
    }

    public void methodB() {
        System.out.println("methodB.......");
        methodA();
        num++;
    }
}

methodB:

Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Class              #8             // com/atguigu/java1/OperandStackTest
   #8 = Utf8               com/atguigu/java1/OperandStackTest
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/atguigu/java1/OperandStackTest;
  #14 = Utf8               testAddOperation
  #15 = Utf8               i
  #16 = Utf8               B
  #17 = Utf8               j
  #18 = Utf8               I
  #19 = Utf8               k
  #20 = Utf8               SourceFile
  #21 = Utf8               OperandStackTest.java
 
 public void methodB();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #27                 // String methodB.......
         5: invokevirtual #21                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: aload_0
         9: invokevirtual #29                 // Method methodA:()V
        12: aload_0
        13: dup
        14: getfield      #7                  // Field num:I
        17: iconst_1
        18: iadd
        19: putfield      #7                  // Field num:I
        22: return
      LineNumberTable:
        line 11: 0
        line 12: 8
        line 13: 12
        line 14: 22
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      23     0  this   Lcom/atguigu/java1/DynamicLinkingTest;

todo: 圖

方法呼叫：解析與分配

在JVM中，將符號引用轉換為呼叫方法的直接引用與方法的繫結機制相關

連結

靜態連結

當一個位元組碼檔案被裝載進JVM內部時，如果被呼叫的目標方法在編譯期可知，且執行期保持不變時，這種情況下降呼叫方法的符號引用轉換為直接引用的過程稱之為靜態連結

動態連結

如果被呼叫的方法在編譯期無法被確定下來，也就是說，只能夠在程式執行期將呼叫的方法的符號轉換為直接引用，由於這種引用轉換過程具備動態性，因此也被稱之為動態連結。

繫結機制

對應的方法的繫結機制為：早期繫結（Early Binding）和晚期繫結（Late Binding）。繫結是一個欄位、方法或者類在符號引用被替換為直接引用的過程，這僅僅發生一次。

早期繫結

早期繫結就是指被呼叫的目標方法如果在編譯期可知，且執行期保持不變時，即可將這個方法與所屬的型別進行繫結，這樣一來，由於明確了被呼叫的目標方法究竟是哪一個，因此也就可以使用靜態連結的方式將符號引用轉換為直接引用。

晚期繫結

如果被呼叫的方法在編譯期無法被確定下來，只能夠在程式執行期根據實際的型別繫結相關的方法，這種繫結方式也就被稱之為晚期繫結。

package com.atguigu.java2;

class Animal {
    public void eat() {
        System.out.println("動物進食");
    }
}

interface Huntable {
    void hunt();
}

class Dog extends Animal implements Huntable {
    @Override
    public void eat() {
        System.out.println("狗吃骨頭");
    }

    @Override
    public void hunt() {
        System.out.println("捕食耗子，多管閒事");
    }
}

class Cat extends Animal implements Huntable {
    public Cat() {
        // 表現為早期繫結
    }

    public Cat(String name) {
        // 表現為早期繫結
        this();
    }

    @Override
    public void eat() {
        System.out.println("貓吃魚");
    }

    @Override
    public void hunt() {
        System.out.println("捕食耗子，天經地義");
    }
}

public class AnimalTest {
    public void showAnimal(Animal animal) {
        // 表現為晚期繫結
        animal.eat();
    }

    public void showHunt(Huntable h) {
        // 表現為晚期繫結
        h.hunt();
    }
}

Invoke special

Invokevirtual

早晚期繫結的發展歷史

隨著高階語言的橫空出世，類似於Java一樣的基於面向物件的程式語言如今越來越多，儘管這類程式語言在語法風格上存在一定的差別，但是它們彼此之間始終保持著一個共性，那就是都支援封裝、繼承和多型等面向物件特性，既然這一類的程式語言具備多型特性，那麼自然也就具備早期繫結和晚期繫結兩種繫結方式。

Java中任何一個普通的方法其實都具備虛擬函式的特徵，它們相當於C++語言中的虛擬函式（C++中則需要使用關鍵字virtual來顯式定義）。如果在Java程式中不希望某個方法擁有虛擬函式的特徵時，則可以使用關鍵字final來標記這個方法。

虛方法和非虛方法

• 如果方法在編譯期就確定了具體的呼叫版本，這個版本在執行時是不可變的。這樣的方法稱為非虛方法。
• 靜態方法、私有方法、final方法、例項構造器、父類方法都是非虛方法。
• 其他方法稱為虛方法。
• 虛擬函式（virtual）：可以由子類繼承並重寫的函式，後期繫結

子類物件的多型的使用前提

• 類的繼承關係
• 方法的重寫

虛擬機器中提供了以下幾條方法呼叫指令：

普通呼叫指令

• invokestatic：呼叫靜態方法，解析階段確定唯一方法版本
• invokespecial：呼叫方法、私有及父類方法，解析階段確定唯一方法版本
• invokevirtual：呼叫所有虛方法
• invokeinterface：呼叫介面方法

動態呼叫指令

• invokedynamic：動態解析出需要呼叫的方法，然後執行

前四條指令固化在虛擬機器內部，方法的呼叫執行不可人為干預，而invokedynamic指令則支援由使用者確定方法版本。其中invokestatic指令和invokespecial指令呼叫的方法稱為非虛方法，其餘的（final修飾的除外）稱為虛方法。

package com.atguigu.java2;

class Father {
    public Father() {
        System.out.println("father的構造器");
    }

    public static void showStatic(String str) {
        System.out.println("father " + str);
    }

    public final void showFinal() {
        System.out.println("father show final");
    }

    public void showCommon() {
        System.out.println("father 普通方法");
    }
}

public class Son extends Father {
    public Son() {
        // invokespecial
        super();
    }

    public Son(int age) {
        // invokespecial
        this();
    }

    /**
     * 不是重寫父類的靜態方法，因為靜態方法不能被重寫
     */
    public static void showStatic(String str) {
        System.out.println("son " + str);
    }

    private void showPrivate(String str) {
        System.out.println("son private " + str);
    }

    public void show() {
        // invokestatic
        showStatic("atguigu.com");
        // invokestatic
        super.showStatic("good");
        // invokespecial
        showPrivate("hello!");
        // invokespecial
        super.showCommon();

        // invokevirtual
        showFinal();    // 因此此方法宣告有final，不能被子類重寫，所以也認為此方法是非虛方法
        // invokevirtual
        showCommon();
        // invokevirtual
        info();

        MethodInterface in = null;
        // invokeinterface
        in.methodA();
    }

    public void info() {

    }

    public void display(Father f) {
        f.showCommon();
    }

    public static void main(String[] args) {
        Son son = new Son();
        son.show();
    }
}

interface MethodInterface {
    void methodA();
}

father的構造器
son atguigu.com
father good
son private hello!
father 普通方法
father show final
father 普通方法
Exception in thread "main" java.lang.NullPointerException
	at com.atguigu.java2.Son.show(Son.java:62)
	at com.atguigu.java2.Son.main(Son.java:75)

Process finished with exit code 1

invokednamic指令

JVM位元組碼指令集一直比較穩定，一直到Java7中才增加了一個invokedynamic指令，這是Java為了「實現動態型別語言」支援而做的一種改進。

但是在Java7中並沒有提供直接生成invokedynamic指令的方法，需要藉助ASM這種底層位元組碼工具來產生invokedynamic指令。直到Java8的Lambda表示式的出現，invokedynamic指令的生成，在Java中才有了直接的生成方式。

Java7中增加的動態語言型別支援的本質是對Java虛擬機器規範的修改，而不是對Java語言規則的修改，這一塊相對來講比較複雜，增加了虛擬機器中的方法呼叫，最直接的受益者就是執行在Java平臺的動態語言的編譯器。

動態型別語言和靜態型別語言

Java仍然是靜態型別語言，但是在一定程度上具有了動態型別語言的特性

動態型別語言和靜態型別語言兩者的區別就在於對型別的檢查是在編譯期還是在執行期，滿足前者就是靜態型別語言，反之是動態型別語言。

說的再直白一點就是，靜態型別語言是判斷變數自身的型別資訊；動態型別語言是判斷變數值的型別資訊，變數沒有型別資訊，變數值才有型別資訊，這是動態語言的一個重要特徵。

例子

Java：

String info = "atguigu";	// info = atguigu報錯

JavaScript：

var name = "shkstart"; 
var name = 10;

Python：

info = 130.5;

package com.atguigu.java2;

@FunctionalInterface
interface Func {
    boolean func(String str);
}

public class Lambda {
    public void lambda(Func func) {
        return;
    }

    public static void main(String[] args) {
        Lambda lambda = new Lambda();
        Func func = s -> true;
        
        lambda.lambda(func);
        lambda.lambda(s -> true);
    }
}

這裡能看到invokedynamic，真正是什麼型別的物件是在執行的時候才能夠確定下來的

方法重寫的本質

Java 語言中方法重寫的本質

• 找到運算元棧頂的第一個元素所執行的物件的實際型別，記作C。
• 如果在型別C中找到與常量中的描述符合簡單名稱都相符的方法，則進行訪問許可權校驗，如果通過則返回這個方法的直接引用，查詢過程結束；如果不通過，則返回java.lang.IllegalAccessError 異常。
• 否則，按照繼承關係從下往上依次對C的各個父類進行第2步的搜尋和驗證過程。
• 如果始終沒有找到合適的方法，則丟擲java.lang.AbstractMethodsrror異常。

IllegalAccessError介紹

程式試圖訪問或修改一個屬性或呼叫一個方法，這個屬性或方法，你沒有許可權訪問。一般的，這個會引起編譯器異常。這個錯誤如果發生在執行時，就說明一個類發生了不相容的改變。

方法的呼叫：虛方法表

在面向物件的程式設計中，會很頻繁的使用到動態分派，如果在每次動態分派的過程中都要重新在類的方法元資料中搜索合適的目標的話就可能影響到執行效率。因此，為了提高效能，JVM採用在類的方法區建立一個虛方法表
（virtual method table）（非虛方法不會出現在表中）來實現。使用索引表來代替查詢。

每個類中都有一個虛方法表，表中存放著各個方法的實際入口。

虛方法表是什麼時候被建立的呢？

虛方法表會在類載入的連結階段被建立並開始初始化，類的變數初始值準備完成之後，JVM會把該類的方法表也初始化完畢。

舉例1

如上圖所示：如果類中重寫了方法，那麼呼叫的時候，就會直接在虛方法表中查詢，否則將會直接連線到Object的方法中。

舉例2

package com.atguigu.java3;

import java.util.Date;

interface Friendly {
    void sayHello();

    void sayGoodbye();
}

class Dog {
    public void sayHello() { }

    @Override
    public String toString() {
        return "Dog{}";
    }
}

class Cat implements Friendly {
    public void eat() { }

    @Override
    public void sayHello() { }

    @Override
    public void sayGoodbye() { }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }

    @Override
    public String toString() {
        return "Cat{}";
    }
}

class CockerSpaniel extends Dog implements Friendly {
    public void sayHello() {
        super.sayHello();
    }

    @Override
    public void sayGoodbye() { }
}

public class VirtualMethodTable {
}

方法返回地址

存放呼叫該方法的pc暫存器的值。一個方法的結束，有兩種方式：

• 正常執行完成
• 出現未處理的異常，非正常退出

無論通過哪種方式退出，在方法退出後都返回到該方法被呼叫的位置。方法正常退出時，呼叫者的pc計數器的值作為返回地址，即呼叫該方法的指令的下一條指令的地址。而通過異常退出的，返回地址是要通過異常表來確定，棧幀中一般不會儲存這部分資訊。

當一個方法開始執行後，只有兩種方式可以退出這個方法：

執行引擎遇到任意一個方法返回的位元組碼指令（return），會有返回值傳遞給上層的方法呼叫者，簡稱正常完成出口；

• 一個方法在正常呼叫完成之後，究竟需要使用哪一個返回指令，還需要根據方法返回值的實際資料型別而定。
• 在位元組碼指令中，返回指令包含ireturn（當返回值是boolean，byte，char，short和int型別時使用），lreturn（long型別），freturn（Float型別），dreturn（Double型別），areturn。另外還有一個return指令宣告為void的方法，例項初始化方法，類和介面的初始化方法使用。

在方法執行過程中遇到異常（Exception），並且這個異常沒有在方法內進行處理，也就是隻要在本方法的異常表中沒有搜尋到匹配的異常處理器，就會導致方法退出，簡稱異常完成出口。

本質上，方法的退出就是當前棧幀出棧的過程。此時，需要恢復上層方法的區域性變量表、運算元棧、將返回值壓入呼叫者棧幀的運算元棧、設定PC暫存器值等，讓呼叫者方法繼續執行下去。

正常完成出口和異常完成出口的區別在於：通過異常完成出口退出的不會給他的上層呼叫者產生任何的返回值。

package com.atguigu.java3;

import java.io.FileReader;
import java.io.IOException;
import java.util.Date;

public class ReturnAddressTest {
    public boolean methodBoolean() {
        return false;
    }

    public byte methodByte() {
        return 0;
    }

    public short methodShort() {
        return 0;
    }

    public char methodChar() {
        return 'a';
    }

    public int methodInt() {
        return 0;
    }

    public long methodLong() {
        return 0L;
    }

    public float methodFloat() {
        return 0.0f;
    }

    public double methodDouble() {
        return 0.0;
    }

    public String methodString() {
        return null;
    }

    public Date methodDate() {
        return null;
    }
    
    public void methodVoid() {
        
    }

    public void method2() {
        methodVoid();
        
        try {
            method1();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void method1() throws IOException {
        FileReader fis = new FileReader("atguigu.txt");
        char[] cBuffer = new char[1024];
        int len;
        while ((len = fis.read(cBuffer)) != -1) {
            String str = new String(cBuffer, 0, len);
            System.out.println(str);
        }
        fis.close();
    }
}

一些附加資訊

棧幀中還允許攜帶與Java虛擬機器實現相關的一些附加資訊。例如：對程式除錯提供支援的資訊。

棧的相關面試題

舉例棧溢位的情況？（StackOverflowError）

• 通過 -Xss設定棧的大小

調整棧大小，就能保證不出現溢位麼？

• 不能保證不溢位，只能讓出現時間更晚一些，但是不能保證不出現

分配的棧記憶體越大越好麼？

給你的錢越多越好嗎？

• 確實吧

• 不是，一定時間內降低了OOM概率，但是會擠佔其它的執行緒空間，因為整個空間是有限的。

垃圾回收是否涉及到虛擬機器棧？

• 不會

方法中定義的區域性變數是否執行緒安全？

• 具體問題具體分析

package com.atguigu.java3;

/**
 * 面試題
 * 方法中定義區域性變數是否執行緒安全？具體情況具體分析
 * 何為執行緒安全？
 * 如果只有一個執行緒才可以操作此資料，則必是執行緒安全的
 * 如果有多個執行緒操作，則此資料是共享資料，如果不考慮共享機制，則為執行緒不安全
 */
public class StringBuilderTest {

    // s1的宣告方式是執行緒安全的，因為是內部產生，內部消亡的
    public static void method01() {
        // 執行緒內部建立的，屬於區域性變數
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
    }

    // 這個也是執行緒不安全的，因為有返回值，有可能被其它的程式所呼叫
    public static StringBuilder method04() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("a");
        stringBuilder.append("b");
        return stringBuilder;
    }

    // stringBuilder 是執行緒不安全的，操作的是共享資料
    public static void method02(StringBuilder stringBuilder) {
        stringBuilder.append("a");
        stringBuilder.append("b");
    }


    /**
     * 同時併發的執行，會出現執行緒不安全的問題
     */
    public static void method03() {
        StringBuilder stringBuilder = new StringBuilder();
        new Thread(() -> {
            stringBuilder.append("a");
            stringBuilder.append("b");
        }, "t1").start();

        method02(stringBuilder);
    }

    // StringBuilder是執行緒安全的，但是String也可能執行緒不安全的，以為返回的是String，可能被其他執行緒呼叫
    public static String method05() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("a");
        stringBuilder.append("b");
        return stringBuilder.toString();
    }
}