public class OperandStackTest {

    public int sum(int a, int b) {
        return a + b;
    }
}

編譯生成.class文件之后，再反匯編查看匯編指令

javac OperandStackTest.java
javap -v OperandStackTest.class

OperandStackTest字節(jié)碼文件

 public int sum(int, int);
    descriptor: (II)I
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=3 // 最大棧深度為2 局部變量個數(shù)為3
         0: iload_1 // 局部變量1 壓棧
         1: iload_2 // 局部變量2 壓棧
         2: iadd    // 棧頂兩個元素相加，計算結(jié)果壓棧
         3: ireturn
      LineNumberTable:
        line 10: 0

動態(tài)鏈接

動態(tài)鏈接：Java虛擬機棧中，每個棧幀都包含一個指向運行時常量池 中 該棧所屬方法的符號引用，持有該引用是為了支持方法調(diào)用過程中的動態(tài)鏈接(Dynamic Linking)。

方法返回地址/方法出口

方法返回地址/方法出口：無論方法是否正常完成，都需要返回到方法被調(diào)用的位置，程序才能繼續(xù)進行

• 方法執(zhí)行時有2種退出情況：
  • 正常退出，即正常執(zhí)行到任何方法的返回字節(jié)碼指令，如 RETURN、IRETURN、ARETURN等
  • 異常退出

無論何種退出情況，都將返回至方法當前被調(diào)用的位置。方法退出的過程相當于彈出當前棧幀，退出可能有3種方式：

• 返回值壓入上層調(diào)用棧幀
• 異常信息拋給能夠處理的棧幀
• PC 計數(shù)器指向方法調(diào)用后的下一條指令

那么要講這個就會涉及到更底層的原理–字節(jié)碼。我們先看下我們上面代碼的字節(jié)碼文件。

看著就是一個16字節(jié)的文件，看著像亂碼，其實每個都是有對應(yīng)的含義的，oracle官方是有專門的Jvm字節(jié)碼指令手冊來查詢每組指令對應(yīng)的含義的。那我們研究的，當然不是這個。

• JDK有自帶一個javap的命令，可以將上述class文件生成一種更可讀的字節(jié)碼文件。
• 我們使用javap -c命令將class文件反編譯并輸出到TXT文件中。

Compiled from "Math.java"
public class com.example.demo.test1.Math {
  public static int initData;
 
  public static com.example.demo.bean.User user;
 
  public com.example.demo.test1.Math();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
 
  public int compute();
    Code:
       0: iconst_1
       1: istore_1
       2: iconst_2
       3: istore_2
       4: iload_1
       5: iload_2
       6: iadd
       7: bipush        10
       9: imul
      10: istore_3
      11: iload_3
      12: ireturn
 
  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class com/example/demo/test1/Math
       3: dup
       4: invokespecial #3                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #4                  // Method compute:()I
      12: pop
      13: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      16: ldc           #6                  // String test
      18: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      21: return
 
  static {};
    Code:
       0: sipush        666
       3: putstatic     #8                  // Field initData:I
       6: new           #9                  // class com/example/demo/bean/User
       9: dup
      10: invokespecial #10                 // Method com/example/demo/bean/User."<init>":()V
      13: putstatic     #11                 // Field user:Lcom/example/demo/bean/User;
      16: return
}

其中方法中的指令還是有點懵，我們舉compute()方法來看一下：

Code:
       0: iconst_1
       1: istore_1
       2: iconst_2
       3: istore_2
       4: iload_1
       5: iload_2
       6: iadd
       7: bipush        10
       9: imul
      10: istore_3
      11: iload_3
      12: ireturn

• 這幾行代碼就是對應(yīng)的我們代碼中compute()方法中的四行代碼。大家都知道越底層的代碼，代碼實現(xiàn)的行數(shù)越多，因為他會包含一些java代碼在運行時底層隱藏的一些細節(jié)原理。

  那么一樣的，這個Jvm指令官方也是有手冊可以查閱的，網(wǎng)上也有很多翻譯版本，大家如果想了解可自行百度。

0. 將int類型常量1壓入操作數(shù)棧

0: iconst_1     

1. 將int類型值存入局部變量1

1: istore_1    

• 局部變量1，在我們代碼中也就是第一個局部變量a，先給a在局部變量表中分配內(nèi)存，然后將int類型的值，也就是目前唯一的一個1存入局部變量a
  

2. 將int類型常量2壓入操作數(shù)棧

2: iconst_2

3. 將int類型值存入局部變量2

3: istore_2

4. 從局部變量1中裝載int類型值

4: iload_1

5. 從局部變量2中裝載int類型值

5: iload_2

• 這兩個代碼是將局部變量1和2，也就是a和b的值裝載到操作數(shù)棧中

6. 執(zhí)行int類型的加法

6: iadd

• iadd指令一執(zhí)行，會將操作數(shù)棧中的1和2依次從棧底彈出并相加，然后把運算結(jié)果3在壓入操作數(shù)棧底。
  

7. 將一個8位帶符號整數(shù)壓入棧

7: bipush        10

• 這個指令就是將10壓入棧
  

8. 執(zhí)行int類型的乘法

9: imul

• 這里就類似上面的加法了，將3和10彈出棧，把結(jié)果30壓入棧
  

9. 將將int類型值存入局部變量3

10: istore_3

• 這里大家就不陌生了吧，和第2步第3步是一樣的，將30存入局部變量3，也就是c

10. 從局部變量3中裝載int類型值

11: iload_3

• 這個前面也說了
  

11. 返回int類型值

12: ireturn

• 這個就不用多說了，就是將操作數(shù)棧中的30返回

到這里就把我們compute()方法講解完了，講完有沒有對局部變量表和操作數(shù)棧的理解有所加深呢？說白了賦值號=后面的就是操作數(shù)，在這些操作數(shù)進行賦值，運算的時候需要往內(nèi)存存放，那就是存放在操作數(shù)棧中，作為臨時存放操作數(shù)的一小塊內(nèi)存區(qū)域。

接下來我們再說說方法出口。

• 方法出口說白了不就是方法執(zhí)行完了之后要出到哪里，那么我們知道上面compute()方法執(zhí)行完之后應(yīng)該回到main()方法第三行那么當main()方法調(diào)用compute()的時候，compute()棧幀中的方法出口就存儲了當前要回到的位置，那么當compute()方法執(zhí)行完之后，會根據(jù)方法出口中存儲的相關(guān)信息回到main()方法的相應(yīng)位置。

3.棧幀與函數(shù)調(diào)用

• 如下圖：函數(shù)1中調(diào)用函數(shù)2，函數(shù)2中調(diào)用函數(shù)3，函數(shù)3調(diào)用函數(shù)4。當函數(shù)1被調(diào)用時，棧幀1入棧，當函數(shù)2調(diào)用時，棧幀2入棧。。。以此類推。當前正在執(zhí)行的函數(shù)所對應(yīng)的幀就是當前幀（位于棧頂），它保存著當前函數(shù)的局部變量、中間計算結(jié)果等數(shù)據(jù)。
  
• 當函數(shù)返回時，棧幀從java棧中被彈出，java方法區(qū)有2種返回函數(shù)的方式，一種是正常的函數(shù)返回，使用return指令，另一種是拋出異常。不管使用哪種方式，都會導(dǎo)致棧幀被彈出。
  • 每次函數(shù)調(diào)用都會產(chǎn)生對應(yīng)的棧幀，占用一定的棧內(nèi)存，如果棧內(nèi)存不足，當請求的棧深度大于最大可用棧深度時，系統(tǒng)會拋出StackOverflowError棧溢出錯誤。

使用遞歸，由于遞歸沒有出口，這段代碼可能會拋出棧溢出錯誤，在拋出棧溢出錯誤時，打印最大的調(diào)用深度

　　public class TestStackDeep {
　　　　private static int count =0;
　　　　public static void recursion(){
　　　　　　count ++;
　　　　　　recursion();
　　　　}

　　　　public static void main(String[] args) {
　　　　　　try{
　　　　　　　　recursion();
　　　　　　}catch(Throwable e){
　　　　　　　　System.out.println("deep of calling ="+count);
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　}
　　}

• 使用參數(shù)-Xss128K執(zhí)行上面代碼

在進行大約1079次調(diào)用之后，發(fā)生了棧溢出錯誤，通過增大-Xss的值，可以獲得更深的層次調(diào)用，嘗試使用參數(shù)-Xss256K執(zhí)行上述代碼，調(diào)用層次有明顯的增加：

結(jié)論：函數(shù)嵌套調(diào)用的層次在很大程度上由棧的大小決定，棧越大，函數(shù)支持的嵌套調(diào)用次數(shù)就越多。

4.棧幀與局部變量表

局部變量表是棧幀的組成部分之一。用于保存函數(shù)的參數(shù)以及局部變量，局部變量表隨著函數(shù)棧幀的彈出而銷毀。

• 如果函數(shù)的參數(shù)和局部變量很多 或 很大，會使得局部變量表膨脹，從而每一次函數(shù)調(diào)用就會占用更多的?？臻g，最終導(dǎo)致函數(shù)的嵌套調(diào)用次數(shù)減少。

例如：一個recursion()函數(shù)含有3個參數(shù)和10個局部變量，因此，其局部變量表含有13個變量，而第二個recursion()函數(shù)不再含有任何參數(shù)和局部變量，當這兩個函數(shù)被嵌套調(diào)用時，第二個recursion函數(shù)可以擁有更深的調(diào)用層次。

public class TestStackDeep2 {
　　private static int count = 0;
　　
　　public static void recursion(long a,long b,long c){
　　　　long e=1,f=2,g=3,h=4,i=5,k=6,q=7,x=8,y=9,z=10;
　　　　count ++;
　　　　recursion(a,b,c);
　　}
　　
　　public static void recursion(){
　　　　count++;
　　　　recursion();
　　}

　　public static void main(String[] args) {
　　　　try{
　　　　　　recursion(0L,0L,0L);
　　　　　　//recursion();
　　　　}catch(Throwable e){
　　　　　　System.out.println("deep of calling = "+count);
　　　　　　e.printStackTrace();
　　　　}
　　}
}

• 使用虛擬機參數(shù)-Xss128K 遞歸執(zhí)行上述代碼中的recursion(long a,long b,long c)函數(shù)，輸出結(jié)果為：
  
• 使用虛擬機參數(shù)-Xss128K 遞歸執(zhí)行不帶參數(shù)的recursion()函數(shù)
  

四.本地方法棧

與虛擬機棧的作用是一樣的，只不過虛擬機棧是服務(wù) Java 方法的，而本地方法棧是為虛擬機調(diào)用本地方法(Native方法)服務(wù)的

• 特性和異常： 同虛擬機棧，請參考上面知識點。即線程私有，StackOverflowError、OutOfMemoryError。

new Thread().start();

public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

其中底層調(diào)用了一個start0()的方法，本地方法，底層通過C語言實現(xiàn)的

private native void start0();

那java代碼里為什么會有C語言實現(xiàn)的本地方法呢？

• 大家都知道JAVA出來之前一個公司的系統(tǒng)百分之九十九都是使用C語言實現(xiàn)的，但是java出現(xiàn)后，很多項目都要轉(zhuǎn)為java開發(fā)，那么新系統(tǒng)和舊系統(tǒng)就免不了要有交互，那么就需要本地方法來實現(xiàn)了，底層是調(diào)用C語言中的dll庫文件，就類似于java中的jar包，當然，如今跨語言的交互方式就很多了，比如`thrift，http接口方式，webservice等，當時并沒有這些方式，就只能通過本地方法來實現(xiàn)了。

  • 那么本地方法始終也是方法，每個線程在運行的時候，如果有運行到本地方法，那么必然也要產(chǎn)生局部變量等，那么就需要存儲在本地方法棧了。如果沒有本地方法，也就沒有本地方法棧了。

五.程序計數(shù)器(PC寄存器/指令切換器)

程序計數(shù)器/*PC寄存器（Program Counter Register）：可以看做是當前線程所執(zhí)行的字節(jié)碼的行號指示器，每個線程都有一個程序計數(shù)器來保存當前執(zhí)行指令的地址，一旦該指令被執(zhí)行，程序計數(shù)器會被更新至下條指令的地址。程序計數(shù)器是Java虛擬機規(guī)定的唯一不會發(fā)生內(nèi)存溢出的區(qū)域。

• 這是一塊較小的內(nèi)存空間（可忽略不記），用于記錄當前線程所執(zhí)行的字節(jié)碼的行號指示器，字節(jié)碼解析器的工作是通過改變這個計數(shù)器的值，來選取下一條需要執(zhí)行的字節(jié)碼指令，分支、循環(huán)、跳轉(zhuǎn)、異常處理、線程恢復(fù)等基礎(chǔ)功能，都需要依賴這個計數(shù)器來完成；

• 特點：線程私有

• 異常規(guī)定：無

那么Jvm虛擬機為什么要設(shè)置程序計數(shù)器這個結(jié)構(gòu)呢？

• 因為Jvm的多線程是通過線程輪流切換并分配處理器執(zhí)行時間(cpu時間片)來的方式來實現(xiàn)的，也就是任何時刻，一個處理器（對于多核處理器來說是一個內(nèi)核）都只會執(zhí)行一條線程中的指令。因此為了線程切換后能恢復(fù)到正確的執(zhí)行位置，每個線程都有獨立的程序計數(shù)器。

  它被設(shè)計出來的目的,是為了讓多線程情況下的JAVA程序每個線程都能夠正常的工作,每個線程都有自己的程序計數(shù)器,用于保存線程的執(zhí)行情況,這樣在進行線程切換的時候就可以在上次執(zhí)行的基礎(chǔ)上繼續(xù)執(zhí)行了

六.元空間

注意：方法區(qū)是一種概念，而永久代和元空間是它的2種實現(xiàn)方式。

1.元空間概念

方法區(qū)即我們常說的永久代(Permanent Generation), 也稱為非堆(No-Heap)、是線程共享的一塊內(nèi)存區(qū)域，用于存儲被 JVM 加載的類信息、常量、靜態(tài)變量、JIT即時編譯器編譯后的代碼 等數(shù)據(jù)

• 運?時常量池： 運?時常量池是?法區(qū)的?部分，Class 文件中除了有 類的版本、字段、方法、接口等描述等信息外，還有一項信息是常量池，用于存放編譯期生成的各種字面量和符號引用，這部分內(nèi)容將在類加載后存放到方法區(qū)的運行時常量池中
• 字?量 : 字符串(JDK 8 移動到堆中)、final常量、基本數(shù)據(jù)類型的值(如Integer，管理-128–127的常量。)。
• 符號引? : 類和結(jié)構(gòu)的完全限定名、字段的名稱和描述符、?法的名稱和描述符。

JDK1.8后永久代被元空間代替，元空間存儲在直接內(nèi)存(系統(tǒng)內(nèi)存),而不在虛擬機當中(不受JVM最大運行內(nèi)存的限制，只和本地內(nèi)存的大小有關(guān)） 其他內(nèi)容比如類元信息、字段、靜態(tài)屬性、方法、常量等都移動到元空間區(qū)。

• 特點：線程共享

• 異常規(guī)定：當方法無法滿足內(nèi)存分配需求時會拋出OutOfMemoryError異常。

  • 默認最小值為16MB，最大值為64MB，可以通過-XX:PermSize 和 -XX:MaxPermSize 參數(shù)限制方法區(qū)的大小

• 運行時常量池是方法區(qū)的一部分，用于存放編譯器生成的各種字面量和符號引用。
  

• JDK1.6字符串常量池在方法區(qū)中，1.7將放在方法區(qū)的字符串常量池放到堆中。**在JDK1.8時徹底去掉了永久代的概念，而在直接內(nèi)存中劃出一塊區(qū)域作為元空間，運行時常量池、類常量池都移動到元空間。。

2.為什么要使用元空間取代永久代的實現(xiàn)

1.避免OOM:

• 方法區(qū)主要是存儲類的相關(guān)信息(包括類的字節(jié)碼文件) , 雖然永久代可以使用PerSize和MaxPerSize等參數(shù)設(shè)置永久代的空間大小, 但隨著ASM、Cglib等動態(tài)生成字節(jié)碼技術(shù)的出現(xiàn)可以修改對象字節(jié)碼信息后,無法控制類信息的大小, 因此對于永久代的大小指定比較困難，太小容易出現(xiàn)永久代溢出，太大則容易導(dǎo)致老年代溢出 ，即 java.lang.OutOfMemoryError: PermGen。
  • JDK1.8使用了元空間替換永久代,因為元空間是使用系統(tǒng)內(nèi)存,由系統(tǒng)的實際可用空間來控制,在一定程度上可以避免OOM的出現(xiàn),但是也需要通過指定MaxMetaspaceSize等參數(shù)來控制大小。

2.提高GC性能:

• 永久代的垃圾收集是和老年代捆綁在一起的,所以無論兩者誰滿了,都會觸發(fā)永久代和老年代的垃圾收集。

  JDK1.7時永久代的部分數(shù)據(jù)已經(jīng)從Java的永久代中轉(zhuǎn)移到了堆中,如:符號引用、字符串常量池

  • 使用元空間替換后,簡化了Full GC,減少了GC的時間(因為GC時不需要再掃描永久代中的數(shù)據(jù)),提高了GC的性能。在元空間中,只有少量指針指向堆,如類的元數(shù)據(jù)中指向class對象的指針。

3.Hotspot和JRockit合并:

• 官方原因,永久代只是Hotspot虛擬機中存在的概念,JRockit中并沒有這個說法,JDK8需要整合Hotspot和JRockit,所以廢棄了永久代,引入了元空間。

七.拓展—直接內(nèi)存

直接內(nèi)存（Direct Memory）: 　也叫堆外內(nèi)存，直接內(nèi)存并不是Jvm管理的內(nèi)存，可以這樣理解就是Jvm以外的機器內(nèi)存，比如，你有4G的內(nèi)存，Jvm占用了1G，則其余的3G就是直接內(nèi)存

• 在JDK 1.4中新加入了NIO（New Input/Output）類，引入了一種基于通道（Channel）與緩沖區(qū)（Buffer）的I/O方式，它可以使用Native函數(shù)庫直接分配堆外內(nèi)存，然后通過一個存儲在Java堆中的DirectByteBuffer對象作為這塊內(nèi)存的引用進行操作。通
  • 通常訪問直接內(nèi)存的速度會優(yōu)于Java堆。因此出于性能的考慮，讀寫頻繁的場合可以考慮使用直接內(nèi)存，避免了在Java堆和Native堆中來回復(fù)制數(shù)據(jù)。
    • 但系統(tǒng)內(nèi)存是有限的，Java堆和直接內(nèi)存的總和依然受限于操作系統(tǒng)能給出的最大內(nèi)存。

八.對象創(chuàng)建

1.對象組成

對象在內(nèi)存中存儲的布局可以分為3塊區(qū)域：對象頭（Header）、實例數(shù)據(jù)（Instance Data）和 對齊填充（Padding）

HotSpot虛擬機的對象頭包括2部分信息：

Mark Word

• 第一部分markword,用于存儲對象自身的運行時數(shù)據(jù)，如哈希碼（HashCode）、GC分代年齡、鎖狀態(tài)標志、線程持有的鎖、偏向線程ID、偏向時間戳等，

• 對象頭的另外一部分是klass類型指針(Klass Pointer)，即對象指向它的Class類元數(shù)據(jù)的指針，虛擬機通過這個指針來確定這個對象是哪個類的實例.

• 數(shù)組長度（只有數(shù)組對象有）： 如果對象是一個數(shù)組, 那在對象頭中還必須有一塊數(shù)據(jù)用于記錄數(shù)組長度.

實例數(shù)據(jù)：

• 第二部分實例數(shù)據(jù)，是對象真正存儲的有效信息，也是在程序代碼中所定義的各種類型的字段內(nèi)容。無論是從父類繼承下來的，還是在子類中定義的，都需要記錄起來。

對齊填充

• 第三部分對齊填充并不是必然存在的，也沒有特別的含義，它僅僅起著占位符的作用。由于HotSpot VM的自動內(nèi)存管理系統(tǒng)要求對象起始地址必須是8字節(jié)的整數(shù)倍，換句話說，就是對象的大小必須是8字節(jié)的整數(shù)倍。而對象頭部分正好是8字節(jié)的倍數(shù)（1倍或者2倍），因此，當對象實例數(shù)據(jù)部分沒有對齊時，就需要通過對齊填充來補全。

其中的類型指針就是那條紅色的線，那是怎么聯(lián)系的呢？

類加載其實最終是以Class對象的形式存儲在方法區(qū)中的，math和math2都是由同一個類new出來的，當對象被new時，都會在對象頭中存儲一個指向類元信息的指針，這就是Klass Pointer類型指針

2.Java中提供的幾種對象創(chuàng)建方式

• 使用new關(guān)鍵字->調(diào)用了構(gòu)造方法
• 使用Class的newInstance方法->調(diào)用了構(gòu)造方法
• 使用Constructor類的newInstance方法->調(diào)用了構(gòu)造方法
• 使用clone方法->沒有調(diào)用構(gòu)造方法
• 使用反序列化->`沒有調(diào)用構(gòu)造方法

3.對象創(chuàng)建的主要流程

虛擬機遇到一條new指令時，先檢查常量池是否已經(jīng)加載相應(yīng)的類，如果沒有，必須先執(zhí)行相應(yīng)的類加載。類加載通過后，接下來分配內(nèi)存。若Java堆中內(nèi)存是絕對規(guī)整的，使用 “指針碰撞“ 方式分配內(nèi)存；如果不是規(guī)整的，就從空閑列表中分配，叫做 ”空閑列表“ 方式。

• 分內(nèi)存時還需要考慮一個問題-并發(fā)，也有2種方式: CAS同步處理，或者本地線程分配緩沖(Thread Local Allocation Buffer, TLAB)。然后內(nèi)存空間初始化操作，接著是做一些必要的對象設(shè)置(元信息、哈希碼…)，最后執(zhí)行<init>方法。

4.對象內(nèi)存分配2種方式

類加載完成后，接著會在Java堆中劃分一塊內(nèi)存分配給對象。內(nèi)存分配根據(jù)Java堆是否規(guī)整，有2種方式：

• 指針碰撞： 如果Java堆的內(nèi)存是規(guī)整，即所有用過的內(nèi)存放在一邊，而空閑的的放在另一邊。分配內(nèi)存時將位于中間的指針指示器向空閑的內(nèi)存移動一段與對象大小相等的距離，這樣便完成分配內(nèi)存工作。
• 空閑列表： 如果Java堆的內(nèi)存是不規(guī)整的，已使用的內(nèi)存和空閑的內(nèi)存相互交錯， 那就沒辦法簡單的進行指針碰撞了， 必須由由虛擬機維護一個列表來記錄那些內(nèi)存是可用的，在分配的時候從列表找到一塊足夠大的內(nèi)存分配給對象，并在分配后更新列表記錄。

5.處理并發(fā)安全問題

對象的創(chuàng)建在虛擬機中是一個非常頻繁的行為，哪怕只是修改一個指針所指向的位置，在并發(fā)情況下也是不安全的，可能出現(xiàn)正在給對象 A 分配內(nèi)存，指針還沒來得及修改，對象 B 又同時使用了原來的指針來分配內(nèi)存的情況。

解決這個問題有兩種方案：

1. 對分配內(nèi)存空間的動作進行同步處理（采用 CAS + 失敗重試來保障更新操作的原子性）；
2. 把內(nèi)存分配的動作按照線程劃分在不同的空間之中進行，即每個線程在 Java 堆中預(yù)先分配一小塊內(nèi)存，稱為本地線程分配緩沖（Thread Local Allocation Buffer, TLAB）。哪個線程要分配內(nèi)存，就在哪個線程的 TLAB 上分配。只有 TLAB 用完并分配新的 TLAB 時，才需要同步鎖。通過-XX:+/-UserTLAB參數(shù)來設(shè)定虛擬機是否使用TLAB。

面試題：（Java實習(xí)生）每日10道面試題打卡——JVM篇文章來源地址http://www.zghlxwxcb.cn/news/detail-830768.html

到了這里，關(guān)于【Jvm】運行時數(shù)據(jù)區(qū)域(Runtime Data Area)原理及應(yīng)用場景的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！