3.虛擬機器棧
一、虛擬機器棧
1.簡介
1.1虛擬機器棧的出現背景
由於跨平臺性的設計，Java的指令都是根據棧來設計的。不同平臺CPU架構不同，所以不能設計為基於暫存器的【如果設計成基於暫存器的，耦合度高，效能會有所提升，因為可以對具體的CPU架構進行優化，但是跨平臺性大大降低】。
優點是跨平臺，指令集小，編譯器容易實現，缺點是效能下降，實現同樣的功能需要更多的指令。
1.2.記憶體中的棧與堆
首先棧是執行時的單位，而堆是儲存的單位。
即：棧解決程式的執行問題，即程式如何執行，或者說如何處理資料。堆解決的是資料儲存的問題，即資料怎麼放，放哪裡
1.3.虛擬機器棧基本內容
Java虛擬機器棧是什麼？
Java虛擬機器棧（Java Virtual Machine Stack），早期也叫Java棧。每個執行緒在建立時都會建立一個虛擬機器棧，其內部儲存一個個的棧幀（Stack Frame），對應著一次次的Java方法呼叫
public class StackTest { public static void main(String[] args) { StackTest test = new StackTest(); test.methodA(); } public void methodA() { int i = 10; int j = 20; methodB(); } public void methodB(){ int k = 30; int m = 40; } }
虛擬機器棧的生命週期
生命週期和執行緒一致，也就是執行緒結束了，該虛擬機器棧也銷燬了
虛擬機器棧的作用
主管Java程式的執行，它儲存方法的區域性變數（8 種基本資料型別、物件的引用地址）、部分結果，並參與方法的呼叫和返回。
區域性變數，它是相比於成員變數來說的（或屬性）
基本資料型別變數 VS 引用型別變數（類、陣列、介面）
1.4虛擬機器棧的特點
棧是一種快速有效的分配儲存方式，訪問速度僅次於程式計數器。
JVM直接對Java棧的操作只有兩個：
每個方法執行，伴隨著進棧（入棧、壓棧）
執行結束後的出棧工作
對於棧來說不存在垃圾回收問題
棧不需要GC，但是可能存在OOM
1.5虛擬機器棧的異常
面試題：棧中可能出現的異常？
Java 虛擬機器規範允許Java棧的大小是動態的或者是固定不變的。
如果採用固定大小的Java虛擬機器棧，那每一個執行緒的Java虛擬機器棧容量可以線上程建立的時候獨立選定。如果執行緒請求分配的棧容量超過Java虛擬機器棧允許的最大容量，Java虛擬機器將會丟擲一個StackoverflowError異常。
如果Java虛擬機器棧可以動態擴充套件，並且在嘗試擴充套件的時候無法申請到足夠的記憶體，或者在建立新的執行緒時沒有足夠的記憶體去建立對應的虛擬機器棧，那Java虛擬機器將會丟擲一個OutofMemoryError異常。
1.6 設定棧記憶體大小
概念
多去官方文件看看：https://docs.oracle.com/en/java/javase/11/tools/java.html#GUID-3B1CE181-CD30-4178-9602-230B800D4FAE
地址經常變
我們可以使用引數-Xss選項來設定執行緒的最大棧空間，棧的大小直接決定了函式呼叫的最大可達深度。
Sets the thread stack size (in bytes). Append the letter
korKto indicate KB,morMto indicate MB, andgorGto indicate GB. The default value depends on the platform:Linux/x64 (64-bit): 1024 KB
macOS (64-bit): 1024 KB
Oracle Solaris/x64 (64-bit): 1024 KB
Windows: The default value depends on virtual memory
The following examples set the thread stack size to 1024 KB in different units:
-Xss1m
-Xss1024k
-Xss1048576
舉例
public class StackErrorTest {
private static int count = 1;
public static void main(String[] args) {
System.out.println(count);
count++;
main(args);
}
}
沒設定引數前
部分輸出結果：
11404
11405
11406
Exception in thread "main" java.lang.StackOverflowError
at sun.nio.cs.UTF_8$Encoder.encodeLoop(UTF_8.java:691)
說明棧在11406這個深度溢位了
設定棧引數之後
部分輸出結果說明引數起作用了
2474
2475
2476
Exception in thread "main" java.lang.StackOverflowError
at sun.nio.cs.UTF_8.updatePositions(UTF_8.java:77)
二、棧的儲存單位
2.1棧中儲存什麼？
每個執行緒都有自己的棧，棧中的資料都是以棧幀（Stack Frame）的格式存在
在這個執行緒上正在執行的每個方法都各自對應一個棧幀（Stack Frame）。
棧幀是一個記憶體區塊，是一個數據集，維繫著方法執行過程中的各種資料資訊。
2.2棧執行原理
JVM直接對Java棧的操作只有兩個，就是對棧幀的壓棧和出棧，遵循先進後出（後進先出）原則
在一條活動執行緒中，一個時間點上，只會有一個活動的棧幀。即只有當前正在執行的方法的棧幀（棧頂棧幀）是有效的。這個棧幀被稱為當前棧幀（Current Frame），與當前棧幀相對應的方法就是當前方法（Current Method），定義這個方法的類就是當前類（Current Class）
執行引擎執行的所有位元組碼指令只針對當前棧幀進行操作。
如果在該方法中呼叫了其他方法，對應的新的棧幀會被創建出來，放在棧的頂端，成為新的當前幀。
不同執行緒中所包含的棧幀是不允許存在相互引用的，即不可能在一個棧幀之中引用另外一個執行緒的棧幀。
如果當前方法呼叫了其他方法，方法返回之際，當前棧幀會傳回此方法的執行結果給前一個棧幀，接著，虛擬機器會丟棄當前棧幀，使得前一個棧幀重新成為當前棧幀。
Java方法有兩種返回函式的方式。
一種是正常的函式返回，使用return指令。
另一種是方法執行中出現未捕獲處理的異常，以丟擲異常的方式結束。
但不管使用哪種方式，都會導致棧幀被彈出。
2.3棧幀的內部結構
每個棧幀中儲存著：
區域性變量表（Local Variables）
運算元棧（Operand Stack）（或表示式棧）
動態連結（Dynamic Linking）（或指向執行時常量池的方法引用）
方法返回地址（Return Address）（或方法正常退出或者異常退出的定義）
一些附加資訊
並行每個執行緒下的棧都是私有的，因此每個執行緒都有自己各自的棧，並且每個棧裡面都有很多棧幀，棧幀的大小主要由區域性變量表 和 運算元棧決定的
三、區域性變量表
3.1認識區域性變量表
3.1.1概念
區域性變量表也被稱之為區域性變數陣列或本地變量表
定義為一個數字陣列，主要用於儲存方法引數和定義在方法體內的區域性變數，這些資料型別包括各類基本資料型別、物件引用（reference），以及returnAddress返回值型別。
由於區域性變量表是建立線上程的棧上，是執行緒的私有資料，因此不存在資料安全問題
區域性變量表所需的容量大小是在編譯期確定下來的，並儲存在方法的Code屬性的maximum local variables資料項中。在方法執行期間是不會改變區域性變量表的大小的。
方法巢狀呼叫的次數由棧的大小決定。一般來說，棧越大，方法巢狀呼叫次數越多。
對一個函式而言，它的引數和區域性變數越多，使得區域性變量表膨脹，它的棧幀就越大，以滿足方法呼叫所需傳遞的資訊增大的需求。
進而函式呼叫就會佔用更多的棧空間，導致其巢狀呼叫次數就會減少。
區域性變量表中的變數只在當前方法呼叫中有效。
在方法執行時，虛擬機器通過使用區域性變量表完成引數值到引數變數列表的傳遞過程。
當方法呼叫結束後，隨著方法棧幀的銷燬，區域性變量表也會隨之銷燬。
3.1.2舉例
public class LocalVariablesTest {
private int count = 0;
public static void main(String[] args) {
LocalVariablesTest test = new LocalVariablesTest();
int num = 10;
test.test1();
}
//練習：
public static void testStatic(){
LocalVariablesTest test = 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";
test2(date, name1);
System.out.println(date + name1);
}
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "songhongkang";
double weight = 130.5;//佔據兩個slot
char gender = '男';
return dateP + name2;
}
public void test3() {
this.count++;
}
public void test4() {
int a = 0;
{
int b = 0;
b = a + 1;
}
//變數c使用之前已經銷燬的變數b佔據的slot的位置
int c = a + 1;
}
}
看完位元組碼後，可得結論：所以區域性變量表所需的容量大小是在編譯期確定下來的。
3.1.3部分詳解
為了更好講解，我們直接用jclasslib來看位元組碼，以main方法為例來講解。一些一目瞭然的就不講了
1、0-15 也就是有16行位元組碼
2、方法異常資訊表
3、Misc
4、行號表
Java程式碼的行號和位元組碼指令行號的對應關係
5、注意：生效行數和剩餘有效行數都是針對於位元組碼檔案的行數
1、圖中圈的東西表示該區域性變數的作用域
2、Start PC==11表示在位元組碼的11行開始生效，也就是Java程式碼對應的第15行。而宣告int num在java程式碼的是第14行，說明是從宣告的下一行開始生效
3、Length== 5表示區域性變數剩餘有效行數，main方法位元組碼指令總共有16行，從11行開始生效，那麼剩下就是16-11 ==5。
4、Ljava/lang/String前面的L表示引用型別
3.2關於Slot的理解
引數值的存放總是從區域性變數陣列索引 0 的位置開始，到陣列長度-1的索引結束。
區域性變量表，最基本的儲存單元是Slot（變數槽），區域性變量表中存放編譯期可知的各種基本資料型別（8種），引用型別（reference），returnAddress型別的變數。
在區域性變量表裡，32位以內的型別只佔用一個slot（包括returnAddress型別），64位的型別佔用兩個slot（1ong和double）。
byte、short、char在儲存前被轉換為int，boolean也被轉換為int，0表示false，非0表示true
long和double則佔據兩個slot
JVM會為區域性變量表中的每一個Slot都分配一個訪問索引，通過這個索引即可成功訪問到區域性變量表中指定的區域性變數值
當一個例項方法被呼叫的時候，它的方法引數和方法體內部定義的區域性變數將會按照順序被複制到區域性變量表中的每一個slot上
如果需要訪問區域性變量表中一個64bit的區域性變數值時，只需要使用前一個索引即可。（比如：訪問long或double型別變數）
如果當前幀是由構造方法或者例項方法建立的，那麼該物件引用this將會存放在index為0的slot處，其餘的引數按照引數表順序繼續排列。（this也相當於一個變數）
3.3 Slot程式碼示例
this 存放在 index = 0 的位置：
程式碼
public void test3() {
this.count++;
}
區域性變量表：this 存放在 index = 0 的位置
64位的型別（1ong和double）佔用兩個slot
程式碼
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "songhongkang";
double weight = 130.5;//佔據兩個slot
char gender = '男';
return dateP + name2;
}
static 無法呼叫 this
this 不存在與 static 方法的區域性變量表中，所以無法呼叫
public static void testStatic(){
LocalVariablesTest test = new LocalVariablesTest();
Date date = new Date();
int count = 10;
System.out.println(count);
//因為this變數不存在於當前方法的區域性變量表中！！
// System.out.println(this.count);
}
3.4 Slot的重複利用
棧幀中的區域性變量表中的槽位是可以重用的，如果一個區域性變數過了其作用域，那麼在其作用域之後申明新的區域性變數變就很有可能會複用過期區域性變數的槽位，從而達到節省資源的目的。
程式碼
public void test4() {
int a = 0;
{
int b = 0;
b = a + 1;
}
//變數c使用之前已經銷燬的變數b佔據的slot的位置
int c = a + 1;
}
區域性變數 c 重用了局部變數 b 的 slot 位置
3.5 靜態變數與區域性變數的對比
變數的分類：
1、按照資料型別分：① 基本資料型別 ② 引用資料型別
2、按照在類中宣告的位置分：
2-1、成員變數：在使用前，都經歷過預設初始化賦值
2-1-1、類變數: linking的prepare階段：給類變數預設賦值
---> initial階段：給類變數顯式賦值即靜態程式碼塊賦值
2-1-2、例項變數：隨著物件的建立，會在堆空間中分配例項變數空間，並進行預設賦值
2-2、區域性變數：在使用前，必須要進行顯式賦值的！否則，編譯不通過。
引數表分配完畢之後，再根據方法體內定義的變數的順序和作用域分配。
我們知道成員變數有兩次初始化的機會，第一次是在“準備階段”，執行系統初始化，對類變數設定零值，另一次則是在“初始化”階段，賦予程式設計師在程式碼中定義的初始值。
和類變數初始化不同的是，區域性變量表不存在系統初始化的過程，這意味著一旦定義了局部變數則必須人為的初始化，否則無法使用。
3.6補充說明
在棧幀中，與效能調優關係最為密切的部分就是前面提到的區域性變量表。在方法執行時，虛擬機器使用區域性變量表完成方法的傳遞。
區域性變量表中的變數也是重要的垃圾回收根節點，只要被區域性變量表中直接或間接引用的物件都不會被回收。
四、運算元棧
4.1運算元棧的特點
每一個獨立的棧幀除了包含區域性變量表以外，還包含一個後進先出（Last - In - First -Out）的 運算元棧，也可以稱之為表示式棧（Expression Stack）
運算元棧，在方法執行過程中，根據位元組碼指令，往棧中寫入資料或提取資料，即入棧（push）和 出棧（pop）
某些位元組碼指令將值壓入運算元棧，其餘的位元組碼指令將運算元取出棧。使用它們後再把結果壓入棧，
比如：執行復制、交換、求和等操作
4.2運算元棧的作用
運算元棧，主要用於儲存計算過程的中間結果，同時作為計算過程中變數臨時的儲存空間。
運算元棧就是JVM執行引擎的一個工作區，當一個方法剛開始執行的時候，一個新的棧幀也會隨之被創建出來，這時方法的運算元棧是空的。
每一個運算元棧都會擁有一個明確的棧深度用於儲存數值，其所需的最大深度在編譯期就定義好了，儲存在方法的Code屬性中，為maxstack的值。
棧中的任何一個元素都是可以任意的Java資料型別
32bit的型別佔用一個棧單位深度
64bit的型別佔用兩個棧單位深度
運算元棧並非採用訪問索引的方式來進行資料訪問的，而是隻能通過標準的入棧和出棧操作來完成一次資料訪問。只不過運算元棧是用陣列這個結構來實現的而已
如果被呼叫的方法帶有返回值的話，其返回值將會被壓入當前棧幀的運算元棧中，並更新PC暫存器中下一條需要執行的位元組碼指令。
運算元棧中元素的資料型別必須與位元組碼指令的序列嚴格匹配，這由編譯器在編譯器期間進行驗證，同時在類載入過程中的類檢驗階段的資料流分析階段要再次驗證。
另外，我們說Java虛擬機器的解釋引擎是基於棧的執行引擎，其中的棧指的就是運算元棧。
區域性變量表就相當於食材
運算元棧就相當於做法步驟
五、運算元棧程式碼追蹤
public void testAddOperation() {
//byte、short、char、boolean：都以int型來儲存
byte i = 15;
int j = 8;
int k = i + j;
// int m = 800;
}
對應位元組碼指令
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
5.1一步一步看流程
1、首先執行第一條語句，PC暫存器指向的是0，也就是指令地址為0，然後使用bipush讓運算元15入運算元棧。
2、執行完後，PC暫存器往下移，指向下一行程式碼，下一行程式碼就是將運算元棧的元素儲存到區域性變量表1的位置（istore_1），我們可以看到區域性變量表的已經增加了一個元素。並且運算元棧為空了
解釋為什麼區域性變量表索引從 1 開始，因為該方法為例項方法，區域性變量表索引為 0 的位置存放的是 this
3、然後PC下移，指向的是下一行。讓運算元8也入棧，同時執行store操作，存入區域性變量表中
4、然後從區域性變量表中，依次將資料放在運算元棧中，等待執行 add 操作
iload_1：取出區域性變量表中索引為1的資料入運算元棧
5、然後將運算元棧中的兩個元素執行相加操作，並存儲在區域性變量表3的位置
5.2小問題
關於型別轉換的說明
因為 8 可以存放在 byte 型別中，所以壓入運算元棧的型別為 byte ，而不是 int ，所以執行的位元組碼指令為 bipush 8
但是儲存在區域性變數的時候，會轉成 int 型別的變數：istore_4
m改成800之後，byte儲存不了，就成了short型，sipush 800
如果被呼叫的方法帶有返回值，返回值入運算元棧
public int getSum(){
int m = 10;
int n = 20;
int k = m + n;
return k;
}
public void testGetSum(){
//獲取上一個棧楨返回的結果，並儲存在運算元棧中
int i = getSum();
int j = 10;
}
getSum() 方法位元組碼指令：最後帶著個 ireturn
testGetSum() 方法位元組碼指令：一上來就載入 getSum() 方法的返回值()
六、棧頂快取技術
棧頂快取技術：Top Of Stack Cashing
前面提過，基於棧式架構的虛擬機器所使用的零地址指令更加緊湊，但完成一項操作的時候必然需要使用更多的入棧和出棧指令，這同時也就意味著將需要更多的指令分派（instruction dispatch）次數（也就是你會發現指令很多）和導致記憶體讀/寫次數多，效率不高。
由於運算元是儲存在記憶體中的，因此頻繁地執行記憶體讀/寫操作必然會影響執行速度。為了解決這個問題，HotSpot JVM的設計者們提出了棧頂快取（Tos，Top-of-Stack Cashing）技術，將棧頂元素全部快取在物理CPU的暫存器中，以此降低對記憶體的讀/寫次數，提升執行引擎的執行效率。
暫存器的主要優點：指令更少，執行速度快，但是指令集（也就是指令種類）很多
七、動態連結
動態連結（或指向執行時常量池的方法引用）
每一個棧幀內部都包含一個指向執行時常量池中該棧幀所屬方法的引用。包含這個引用的目的就是為了支援當前方法的程式碼能夠實現動態連結（Dynamic Linking），比如：invokedynamic指令
在Java原始檔被編譯到位元組碼檔案中時，所有的變數和方法引用都作為符號引用（Symbolic Reference）儲存在class檔案的常量池裡。比如：描述一個方法呼叫了另外的其他方法時，就是通過常量池中指向方法的符號引用來表示的，那麼動態連結的作用就是為了將這些符號引用轉換為呼叫方法的直接引用
public class DynamicLinkingTest {
int num = 10;
public void methodA(){
System.out.println("methodA()....");
}
public void methodB(){
System.out.println("methodB()....");
methodA();
num++;
}
}
對應位元組碼
Classfile /F:/IDEAWorkSpaceSourceCode/JVMDemo/out/production/chapter05/com/atguigu/java1/DynamicLinkingTest.class
Last modified 2020-11-10; size 712 bytes
MD5 checksum e56913c945f897c7ee6c0a608629bca8
Compiled from "DynamicLinkingTest.java"
public class com.atguigu.java1.DynamicLinkingTest
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #9.#23 // java/lang/Object."<init>":()V
#2 = Fieldref #8.#24 // com/atguigu/java1/DynamicLinkingTest.num:I
#3 = Fieldref #25.#26 // java/lang/System.out:Ljava/io/PrintStream;
#4 = String #27 // methodA()....
#5 = Methodref #28.#29 // java/io/PrintStream.println:(Ljava/lang/String;)V
#6 = String #30 // methodB()....
#7 = Methodref #8.#31 // com/atguigu/java1/DynamicLinkingTest.methodA:()V
#8 = Class #32 // com/atguigu/java1/DynamicLinkingTest
#9 = Class #33 // java/lang/Object
#10 = Utf8 num
#11 = Utf8 I
#12 = Utf8 <init>
#13 = Utf8 ()V
#14 = Utf8 Code
#15 = Utf8 LineNumberTable
#16 = Utf8 LocalVariableTable
#17 = Utf8 this
#18 = Utf8 Lcom/atguigu/java1/DynamicLinkingTest;
#19 = Utf8 methodA
#20 = Utf8 methodB
#21 = Utf8 SourceFile
#22 = Utf8 DynamicLinkingTest.java
#23 = NameAndType #12:#13 // "<init>":()V
#24 = NameAndType #10:#11 // num:I
#25 = Class #34 // java/lang/System
#26 = NameAndType #35:#36 // out:Ljava/io/PrintStream;
#27 = Utf8 methodA()....
#28 = Class #37 // java/io/PrintStream
#29 = NameAndType #38:#39 // println:(Ljava/lang/String;)V
#30 = Utf8 methodB()....
#31 = NameAndType #19:#13 // methodA:()V
#32 = Utf8 com/atguigu/java1/DynamicLinkingTest
#33 = Utf8 java/lang/Object
#34 = Utf8 java/lang/System
#35 = Utf8 out
#36 = Utf8 Ljava/io/PrintStream;
#37 = Utf8 java/io/PrintStream
#38 = Utf8 println
#39 = Utf8 (Ljava/lang/String;)V
{
int num;
descriptor: I
flags:
public com.atguigu.java1.DynamicLinkingTest();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush 10
7: putfield #2 // Field num:I
10: return
LineNumberTable:
line 7: 0
line 9: 4
LocalVariableTable:
Start Length Slot Name Signature
0 11 0 this Lcom/atguigu/java1/DynamicLinkingTest;
public void methodA();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #4 // String methodA()....
5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 12: 0
line 13: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this Lcom/atguigu/java1/DynamicLinkingTest;
public void methodB();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=1, args_size=1
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String methodB()....
5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: aload_0
9: invokevirtual #7 // Method methodA:()V
12: aload_0
13: dup
14: getfield #2 // Field num:I
17: iconst_1
18: iadd
19: putfield #2 // Field num:I
22: return
LineNumberTable:
line 16: 0
line 18: 8
line 20: 12
line 21: 22
LocalVariableTable:
Start Length Slot Name Signature
0 23 0 this Lcom/atguigu/java1/DynamicLinkingTest;
}
SourceFile: "DynamicLinkingTest.java"
1、在位元組碼指令中，methodB() 方法中通過 invokevirtual #7 指令呼叫了方法 A ，那麼 #7 是個啥呢？
2、往上面翻，找到常量池的定義：#7 = Methodref #8.#31
先找 #8 ：
#8 = Class #32：去找 #32
#32 = Utf8 com/atguigu/java1/DynamicLinkingTest
結論：通過 #8 我們找到了DynamicLinkingTest這個類
再來找 #31：
#31 = NameAndType #19:#13：去找 #19 和 #13
#19 = Utf8 methodA：方法名為 methodA
#13 = Utf8 ()V：方法沒有形參，返回值為 void
3、結論：通過 #7 我們就能找到需要呼叫的 methodA() 方法，並進行呼叫
4、在上面，其實還有很多符號引用，比如 Object、System、PrintStream 等等
為什麼要用常量池呢？
因為在不同的方法，都可能呼叫常量或者方法，所以只需要儲存一份即可，然後記錄其引用即可，節省了空間。
常量池的作用：就是為了提供一些符號和常量，便於指令的識別
八、方法的呼叫
8.1靜態連結與動態連結
在JVM中，將符號引用轉換為呼叫方法的直接引用與方法的繫結機制相關
靜態連結：
當一個位元組碼檔案被裝載進JVM內部時，如果被呼叫的目標方法在編譯期確定，且執行期保持不變時，這種情況下將呼叫方法的符號引用轉換為直接引用的過程稱之為靜態連結
動態連結：
如果被呼叫的方法在編譯期無法被確定下來，也就是說，只能夠在程式執行期將呼叫的方法的符號轉換為直接引用，由於這種引用轉換過程具備動態性，因此也被稱之為動態連結。
8.2早期繫結與晚期繫結
靜態連結與動態連結針對的是方法。早期繫結和晚期綁定範圍更廣。早期繫結涵蓋了靜態連結，晚期繫結涵蓋了動態連結。
靜態連結和動態連結對應的方法的繫結機制為：早期繫結（Early Binding）和晚期繫結（Late Binding）。繫結是一個欄位、方法或者類在符號引用被替換為直接引用的過程，這僅僅發生一次。
早期繫結
早期繫結就是指被呼叫的目標方法如果在編譯期可知，且執行期保持不變時，即可將這個方法與所屬的型別進行繫結，這樣一來，由於明確了被呼叫的目標方法究竟是哪一個，因此也就可以使用靜態連結的方式將符號引用轉換為直接引用。
晚期繫結
如果被呼叫的方法在編譯期無法被確定下來，只能夠在程式執行期根據實際的型別繫結相關的方法，這種繫結方式也就被稱之為晚期繫結。
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() {
super();//表現為：早期繫結
}
public Cat(String name) {
this();//表現為：早期繫結
}
@Override
public void eat() {
super.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();//表現為：晚期繫結
}
}
部分位元組碼
public com.atguigu.java2.AnimalTest();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 54: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/atguigu/java2/AnimalTest;
public void showAnimal(com.atguigu.java2.Animal);
descriptor: (Lcom/atguigu/java2/Animal;)V
flags: ACC_PUBLIC
Code:
stack=1, locals=2, args_size=2
0: aload_1
1: invokevirtual #2 // Method com/atguigu/java2/Animal.eat:()V
4: return
LineNumberTable:
line 56: 0
line 57: 4
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/atguigu/java2/AnimalTest;
0 5 1 animal Lcom/atguigu/java2/Animal;
public void showHunt(com.atguigu.java2.Huntable);
descriptor: (Lcom/atguigu/java2/Huntable;)V
flags: ACC_PUBLIC
Code:
stack=1, locals=2, args_size=2
0: aload_1
1: invokeinterface #3, 1 // InterfaceMethod com/atguigu/java2/Huntable.hunt:()V
6: return
LineNumberTable:
line 60: 0
line 61: 6
LocalVariableTable:
Start Length Slot Name Signature
0 7 0 this Lcom/atguigu/java2/AnimalTest;
0 7 1 h Lcom/atguigu/java2/Huntable;
}
SourceFile: "AnimalTest.java"
invokevirtual 體現為晚期繫結
invokeinterface 也體現為晚期繫結
invokespecial 體現為早期繫結
8.3多型與繫結
隨著高階語言的橫空出世，類似於Java一樣的基於面向物件的程式語言如今越來越多，儘管這類程式語言在語法風格上存在一定的差別，但是它們彼此之間始終保持著一個共性，那就是都支援封裝、繼承和多型等面向物件特性，既然這一類的程式語言具備多型特性，那麼自然也就具備早期繫結和晚期繫結兩種繫結方式。
Java中任何一個普通的方法其實都具備虛擬函式的特徵，它們相當於C++語言中的虛擬函式（C++中則需要使用關鍵字virtual來顯式定義）。如果在Java程式中不希望某個方法擁有虛擬函式的特徵時，則可以使用關鍵字final來標記這個方法。
8.3.1虛方法與非虛方法
虛方法與非虛方法的區別
如果方法在編譯期就確定了具體的呼叫版本，這個版本在執行時是不可變的。這樣的方法稱為非虛方法。
靜態方法、私有方法、final方法、例項構造器、父類方法都是非虛方法。
其他方法稱為虛方法。
子類物件的多型的使用前提：
類的繼承關係
方法的重寫
虛擬機器中呼叫方法的指令
普通指令：
invokestatic：呼叫靜態方法，解析階段確定唯一方法版本
invokespecial：呼叫<init>方法、私有及父類方法，解析階段確定唯一方法版本
invokevirtual：呼叫所有虛方法
invokeinterface：呼叫介面方法
動態呼叫指令
invokedynamic：動態解析出需要呼叫的方法，然後執行
前四條指令固化在虛擬機器內部，方法的呼叫執行不可人為干預。而invokedynamic指令則支援由使用者確定方法版本。其中invokestatic指令和invokespecial指令呼叫的方法稱為非虛方法，其餘的（final修飾的除外）稱為虛方法。
8.3.2舉例
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 你沒有顯示的加super.，編譯器認為你可能呼叫子類的showCommon(即使son子類沒有重寫，也 會認為)，所以編譯期間確定不下來，就是虛方法。
*/
showCommon();
info();
MethodInterface in = null;
//invokeinterface
in.methodA();
}
public void info() {
}
public void display(Father f) {
f.showCommon();
}
public static void main(String[] args) {
Son so = new Son();
so.show();
}
}
interface MethodInterface {
void methodA();
}
Son 類中 show() 方法的位元組碼指令如下
8.3.3關於 invokedynamic 指令
JVM位元組碼指令集一直比較穩定，一直到Java7中才增加了一個invokedynamic指令，這是Java為了實現【動態型別語言】支援而做的一種改進。
但是在Java7中並沒有提供直接生成invokedynamic指令的方法，需要藉助ASM這種底層位元組碼工具來產生invokedynamic指令。直到Java8的Lambda表示式的出現，invokedynamic指令的生成，在Java中才有了直接的生成方式。
Java7中增加的動態語言型別支援的本質是對Java虛擬機器規範的修改，而不是對Java語言規則的修改，這一塊相對來講比較複雜，增加了虛擬機器中的方法呼叫，最直接的受益者就是執行在Java平臺的動態語言的編譯器。
@FunctionalInterface
interface Func {
public 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 -> {
return true;
};
lambda.lambda(func);
lambda.lambda(s -> {
return true;
});
}
}
8.4動態語言和靜態語言
動態型別語言和靜態型別語言兩者的區別就在於對型別的檢查是在編譯期還是在執行期，滿足前者就是靜態型別語言，反之是動態型別語言。
說的再直白一點就是，靜態型別語言是判斷變數自身的型別資訊；動態型別語言是判斷變數值的型別資訊，變數沒有型別資訊，變數值才有型別資訊，這是動態語言的一個重要特徵。
Java：String info = “mogu blog”; (Java是靜態型別語言的，會先編譯就進行型別檢查)
JS：var name = “shkstart”; var name = 10; （執行時才進行檢查）
Python: info = 130.5 (執行時才檢查)
8.5 Java語言中方法重寫的本質
找到運算元棧頂的第一個元素所執行的物件的實際型別，記作C。
如果在型別C中找到與常量中的描述符合簡單名稱都相符的方法，則進行訪問許可權校驗。
如果通過則返回這個方法的直接引用，查詢過程結束
如果不通過，則返回java.lang.IllegalAccessError 異常
否則，按照繼承關係從下往上依次對C的各個父類進行第2步的搜尋和驗證過程。
如果始終沒有找到合適的方法，則丟擲java.lang.AbstractMethodError異常。
上面這個過程稱為動態分派
IllegalAccessError介紹
程式試圖訪問或修改一個屬性或呼叫一個方法，這個屬性或方法，你沒有許可權訪問。一般的，這個會引起編譯器異常。這個錯誤如果發生在執行時，就說明一個類發生了不相容的改變。
比如，你把應該有的jar包放從工程中拿走了，或者Maven中存在jar包衝突
8.6虛方法表
在面向物件的程式設計中，會很頻繁的使用到動態分派，如果在每次動態分派的過程中都要重新在類的方法元資料中搜索合適的目標的話就可能影響到執行效率。因此，為了提高效能，JVM採用在類的方法區建立一個虛方法表（virtual method table）來實現，非虛方法不會出現在表中。使用索引表來代替查詢。【上面動態分派的過程，我們可以看到如果子類找不到，還要從下往上找其父類，非常耗時】
每個類中都有一個虛方法表，表中存放著各個方法的實際入口。
虛方法表是什麼時候被建立的呢？虛方法表會在類載入的連結階段被建立並開始初始化，類的變數初始值準備完成之後，JVM會把該類的虛方法表也初始化完畢。
例子1
如圖所示：如果類中重寫了方法，那麼呼叫的時候，就會直接在該類的虛方法表中查詢
1、比如說son在呼叫toString的時候，Son沒有重寫過，Son的父類Father也沒有重寫過，那就直接呼叫Object類的toString。那麼就直接在虛方法表裡指明toString直接指向Object類。
2、下次Son物件再呼叫toString就直接去找Object，不用先找Son–>再找Father–>最後才到Object的這樣的一個過程。
例子2
九、方法返回地址
在一些帖子裡，方法返回地址、動態連結、一些附加資訊 也叫做幀資料區
存放呼叫該方法的pc暫存器的值。一個方法的結束，有兩種方式：
正常執行完成
出現未處理的異常，非正常退出
無論通過哪種方式退出，在方法退出後都返回到該方法被呼叫的位置。方法正常退出時，呼叫者的pc計數器的值作為返回地址，即呼叫該方法的指令的下一條指令的地址。而通過異常退出的，返回地址是要通過異常表來確定，棧幀中一般不會儲存這部分資訊。
本質上，方法的退出就是當前棧幀出棧的過程。此時，需要恢復上層方法的區域性變量表、運算元棧、將返回值壓入呼叫者棧幀的運算元棧、設定PC暫存器值等，讓呼叫者方法繼續執行下去。
正常完成出口和異常完成出口的區別在於：通過異常完成出口退出的不會給他的上層呼叫者產生任何的返回值。
方法退出的兩種方式
當一個方法開始執行後，只有兩種方式可以退出這個方法，
正常退出：
執行引擎遇到任意一個方法返回的位元組碼指令（return），會有返回值傳遞給上層的方法呼叫者，簡稱正常完成出口；
一個方法在正常呼叫完成之後，究竟需要使用哪一個返回指令，還需要根據方法返回值的實際資料型別而定。
在位元組碼指令中，返回指令包含：
ireturn：當返回值是boolean，byte，char，short和int型別時使用
lreturn：Long型別
freturn：Float型別
dreturn：Double型別
areturn：引用型別
return：返回值型別為void的方法、例項初始化方法、類和介面的初始化方法
異常退出：
在方法執行過程中遇到異常（Exception），並且這個異常沒有在方法內進行處理，也就是隻要在本方法的異常表中沒有搜尋到匹配的異常處理器，就會導致方法退出，簡稱異常完成出口。
方法執行過程中，丟擲異常時的異常處理，儲存在一個異常處理表，方便在發生異常的時候找到處理異常的程式碼
異常處理表：
反編譯位元組碼檔案，可得到 Exception table
from ：位元組碼指令起始地址
to ：位元組碼指令結束地址
target ：出現異常跳轉至地址為 11 的指令執行
type ：捕獲異常的型別
十、一些附加資訊
棧幀中還允許攜帶與Java虛擬機器實現相關的一些附加資訊。例如：對程式除錯提供支援的資訊。
十一、棧相關面試題
舉例棧溢位的情況？
SOF（StackOverflowError），棧大小分為固定的，和動態變化。如果是固定的就可能出現StackOverflowError。如果是動態變化的，記憶體不足時就可能出現OOM
調整棧大小，就能保證不出現溢位麼？
不能保證不溢位，只能保證SOF出現的機率小
分配的棧記憶體越大越好麼？
不是，一定時間內降低了OOM概率，但是會擠佔其它的執行緒空間，因為整個虛擬機器的記憶體空間是有限的
垃圾回收是否涉及到虛擬機器棧？
不會
| 位置 | 是否有Error | 是否存在GC |
|---|---|---|
| PC計數器 | 無 | 不存在 |
| 虛擬機器棧 | 有，SOF | 不存在 |
| 本地方法棧(在HotSpot的實現中和虛擬機器棧一樣) | ||
| 堆 | 有，OOM | 存在 |
| 方法區 | 有 | 存在 |
方法中定義的區域性變數是否執行緒安全？
具體問題具體分析
如果只有一個執行緒才可以操作此資料，則必是執行緒安全的。
如果有多個執行緒操作此資料，則此資料是共享資料。如果不考慮同步機制的話，會存線上程安全問題。
具體問題具體分析：
如果物件是在內部產生，並在內部消亡，沒有返回到外部，那麼它就是執行緒安全的，反之則是執行緒不安全的。
/**
* 面試題：
* 方法中定義的區域性變數是否執行緒安全？具體情況具體分析
*
* 何為執行緒安全？
* 如果只有一個執行緒才可以操作此資料，則必是執行緒安全的。
* 如果有多個執行緒操作此資料，則此資料是共享資料。如果不考慮同步機制的話，會存線上程安全問題。
*/
public class StringBuilderTest {
int num = 10;
//s1的宣告方式是執行緒安全的（只在方法內部用了）
public static void method1(){
//StringBuilder:執行緒不安全
StringBuilder s1 = new StringBuilder();
s1.append("a");
s1.append("b");
//...
}
//sBuilder的操作過程：是執行緒不安全的（作為引數傳進來，可能被其它執行緒操作）
public static void method2(StringBuilder sBuilder){
sBuilder.append("a");
sBuilder.append("b");
//...
}
//s1的操作：是執行緒不安全的（有返回值，可能被其它執行緒操作）
public static StringBuilder method3(){
StringBuilder s1 = new StringBuilder();
s1.append("a");
s1.append("b");
return s1;
}
//s1的操作：是執行緒安全的（s1自己消亡了，最後返回的只是s1.toString的一個新物件）
public static String method4(){
StringBuilder s1 = new StringBuilder();
s1.append("a");
s1.append("b");
return s1.toString();
}
public static void main(String[] args) {
StringBuilder s = new StringBuilder();
new Thread(() -> {
s.append("a");
s.append("b");
}).start();
method2(s);
}
}