• Sun Classic VM 只用解譯器，會一行一行執行，即使 for 迴圈也一樣，而 JIT 編譯器可以尋找熱點程式碼，也就是執行頻率高的程式碼，會將其編成本地機器指令，然後快取起來，下次反覆執行就不會先由解譯器逐行再去翻譯，但所有程式碼都會被編譯為機器碼需要時間長

• Exact VM

• HotSpot 目前稱霸

• JRockit

• IBM的J9

• KVM和CDC/CLDC Hotspot

• Azul VM

• Liquid VM

• Apache Harmony

• Microsoft JVM

• TaobaoJVM

特定檔案標識 : 二進位開頭 ca fe ba be , 所有能被 Java 虛擬機器識別的都有這個標識

實體磁碟上 car.class 檔案以二進位流的方式載入到記憶體中 實例化對應: 記憶體中呼叫 car 的建構子或建構方法

the method content is as follows

if there is no merging of class variable (static variable) assignment actions and static code block statements, there will be no<clinit>method, such as

in other words, only with static variablesassignmentwill there be<clinit>method, and if there is no assignment there is also none

only one thread executes, and the virtual machine guarantees that the class is executed only once when it is loaded<clinit>method, the methods in static are<clinit>a manifestation of the method, and static executes only once, which shows that <clinit>the method executes only once

• bootstrap class loader: Java core class libraries are all loaded using the bootstrap class loader

• extension class loader: ExtClassLoade

• system class loader: AppClassLoade (application class loader)(user default loader)

    public static void main(String[] args) {  
  
        //取得系統類別載入器  
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();  
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2  
  
        //取得其上層：擴充類別載入器  
        ClassLoader extClassLoader = systemClassLoader.getParent();  
        System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@1540e19d  
  
        //取得其上層：取得不到啟動類別載入器  
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();  
        System.out.println(bootstrapClassLoader);//null  
  
        //對於使用者自訂類別來說：預設使用系統類別載入器進行載入  
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();  
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2  
		System.out.println(classLoader.getParent());//sun.misc.Launcher$ExtClassLoader@1b6d3586
		
        //String類別使用啟動類別載入器進行載入。---> Java的核心類別庫都是使用啟動類別載入器進行載入的
        ClassLoader classLoader1 = String.class.getClassLoader();  
        System.out.println(classLoader1);//null  
    }  

public static void main(String[] args) {  
    System.out.println("**********启动类加载器**************");  
    //取得BootstrapClassLoader能夠載入的api的路徑  
    URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs();  
    for (URL element : urLs) {  
        System.out.println(element.toExternalForm());  
    }  
    //從上面的路徑中隨意選擇一個類別,來看看它的類別載入器是什麼:啟動類別載入器  
    ClassLoader classLoader = Provider.class.getClassLoader();  
    System.out.println(classLoader);//null  
  
    System.out.println("***********扩展类加载器*************");  
    //System.getProperty():取得指定的Java系統屬性  
    //"java.ext.dirs":這個屬性鍵表示Java擴充目錄屬性  
    String extDirs = System.getProperty("java.ext.dirs");  
    for (String path : extDirs.split(";")) {  
        System.out.println(path);  
    }  
    //從上面的路徑中隨意選擇一個類別,來看看它的類別載入器是什麼:擴充類別載入器  
    ClassLoader classLoader1 = SunEC.class.getClassLoader();  
    System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1b6d3586  
}

new UserClassLoader(載入路徑)

結果自己建立的 String 沒有自身系統類別載入器使用，而是委託最上層父類別載入器去載入，最上層載入器會看所屬套件，如果不屬於自己的管理範疇，則會繼續向下委託給擴充類別載入器，擴充類別載入器看如果也不屬於自己的管理範疇，則也不管，才委託給系統類別載入器 委託給啟動類別載入器後，發現 java 中真正的 String 中根本沒有 main 方法，就直接忽略掉了自己寫的 string，如果官方版本存在，就會忽略自訂版本

會沒有權限，直接報錯，禁止了自訂類別使用核心 API 的套件名稱

紅色表示一個行程一份 灰色表示一個執行緒一份

在Hotspot JVM裡，每個執行緒都與作業系統的原生執行緒直接對應。 當一個Java執行緒準備好執行以後，此時一個作業系統的原生執行緒也同時建立。Java執行緒執行終止後，原生執行緒也會回收。 作業系統負責所有執行緒的安排調度到任何一個可用的CPU上。一旦原生執行緒初始化成功，它就會呼叫Java執行緒中的run ()方法

指定位址（偏移位址）PC暫存器儲存的資料

看著像是並行，實際是一個一個執行

食材明細 --> 變數 步驟 -->位元組碼指令 食材 -- > 堆積

• 優點

只呼叫了1000多次

局部變數表長度 locals=3 L代表參照型別 局部變數表的容量大小在編譯器就確認下來了 最後還有一個收尾的大括號代表一個

變數個數 該java程式碼所對應的位元組碼長度 start （位元組碼指令行號） 和 line Number （程式碼行號）的對應

位元組碼指令對應的就是java指令內容

LineNumberTable ： 位元組碼行和程式碼行對應表 局部變數的描述

根據索引使用相應變數

start pc是位元組碼指令行數 length描述當前變數作用域的範圍(即pc開始往後的位元組碼範圍) 如pc 8, length8 ,即位元組碼行號為8-8+8的作用範圍 start pc其實就是起始的範圍 index 是索引

如num --> pc11 --> line 16:即作用域的開始是聲明的下一行

start pc + length = code length

存取佔用 64 位的局部變數值，只需要使用前一個索引即可 如果當前幀是由建構方法或者實例方法建立的，那麼該物件參照 this 將會存放在 index 為 0 的 slot 處，其餘的參數按照參數表順序繼續排列

對於 static 方法 : this 變數則不存在於當前方法的局部變數表中，由於 static 方法是 屬於類 而不是實例的，它不需要通過 this 關鍵字引用當前物件。在 static 方法中，不存在當前物件的引用，因此局部變數表中不會分配 this 變數

weight佔據兩個3,4

• 建構子

b過了作用域還佔據著slot,目前還沒有被重複利用

c重複利用了b的index空間,

既有棧的特點，也具有陣列或鏈結串列的特點

0 bipush 15 //bipush(push byte)將一個位元組的常量值推送到運算元堆疊上(bipushbyte-->int ;sipush是short-->int) 2 istore_1 //Integer STORE_ X表示將運算元堆疊上資料儲存到局部變數表的索引X的位置 3 bipush 8 5 istore_2 6 iload_1 // iload_X將區域變數表的資料 X 放到運算元堆疊 7 iload_2 8 iadd // 將運算元堆疊的資料相加 9 istore_3 // 10 return

• 區域變數表中，byte 會以 int 形式儲存
• 運算元堆疊中，bipush 指令壓入的是 byte 類型

為什麼位元組碼指令之間的編號似乎不連續

aload_0 的含義是將目前物件參考載入到運算元堆疊上

對於左邊沒有賦值操作的 i++ 和 ++i 位元組碼指令一樣

對於左邊有賦值操作的 i++ 先load出來再incre by ++i 先incre by 再load出來

    public void add(){  
        //第1類問題：  
        int i1 = 10;  
        i1++;  
//        0 bipush 10  
//        2 istore_1  
//        3 iinc 1 by 1  
        int i2 = 10;  
        ++i2;  
//        6 bipush 10  
//        8 istore_2  
//        9 iinc 2 by 1  
  
        //第2類問題：  
        int i3 = 10;  
        int i4 = i3++;  
//        12 bipush 10  
//        14 istore_3  
//        15 iload_3  
//        16 iinc 3 by 1  
//        19 istore 4  
        int i5 = 10;  
        int i6 = ++i5;  
//        21 bipush 10  
//        23 istore 5  
//        25 iinc 5 by 1  
//        28 iload 5  
//        30 istore 6  
  
        //第3類問題：  
        int i7 = 10;  
        i7 = i7++;  
//        32 bipush 10  
//        34 istore 7  
//        36 iload 7  
//        38 iinc 7 by 1  
//        41 istore 7  
        int i8 = 10;  
        i8 = ++i8;  
//        43 bipush 10  
//        45 istore 8  
//        47 iinc 8 by 1  
//        50 iload 8  
//        52 istore 8  
        //第4類問題：  
        int i9 = 10;  
        int i10 = i9++ + ++i9;  
//        54 bipush 10  
//        56 istore 9  
//        58 iload 9  
//        60 iinc 9 by 1  
//        63 iinc 9 by 1  
//        66 iload 9  
//        68 iadd  
//        69 istore 10  
//        71 return  
    }

maven : jar 套件衝突可能出現

返回情況 位元組碼行號

本地方法會壓入本地方法堆疊，由動態連結的方式呼叫 C 中的函式庫，由執行引擎執行

現在說的區沒有包括元空間或永久區

• 新生代 Survivor 只會用一個

• 養老代

• 

public static void main(String[] args) {  
  
    //回傳Java虛擬機中的堆積記憶體總量  
    // 執行時資料區是單例  
    long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;  
    //回傳Java虛擬機試圖使用的最大堆積記憶體量  
    long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;  
  
    System.out.println("-Xms : " + initialMemory + "M");  
    System.out.println("-Xmx : " + maxMemory + "M");  
  
    System.out.println("系统内存大小为：" + initialMemory * 64.0 / 1024 + "G");  
    System.out.println("系统内存大小为：" + maxMemory * 4.0 / 1024 + "G");  
  
    try {  
        Thread.sleep(1000000);  
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    }  
}

配置新生代老年代比例

伊甸園區滿後會觸發 GC 回收回收，順便回收 survival, 但 survival 滿時不會觸發 GC 回收 年齡計數器: 數值 S0, S1 哪個空哪個是 to, 另一個 from, to 代表下一次放的地方

老年代空間不足時會進行一次垃圾回收，回收後仍然不足才會爆OOM，爆OOM前必然會有Full GC -Xms9m -Xmx9m -XX:+PrintGCDetails

public static void main(String[] args) {  
    int i = 0;  
    try {  
        List<String> list = new ArrayList<>();  
        String a = "atguigu.com";  
        while (true) {  
            list.add(a);  
            a = a + a;  
            i++;  
        }  
  
    } catch (Throwable t) {  
        t.printStackTrace();  
        System.out.println("遍历次数为：" + i);  
    }  
}

[GC (Allocation Failure) [PSYoungGen: 2027K->504K（回收後新生代大小）(2560K)總空間大小] 2027K堆空間回收前（和前面一樣因為這時候堆空間老年代沒資料）->926K堆空間回收後，不一樣了，這時說明有資料放到老年代了(9728K)堆空間總大小, 0.0007621 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2210K->512K(2560K)] 2632K->1610K(9728K), 0.0006082 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2310K->496K(2560K)] 3408K->2346K(9728K), 0.0007793 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 1238K->512K(2560K)] 7313K->6602K(9728K), 0.0005005 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 512K->496K(2560K)] 6602K->6602K(9728K)最後 新生代放到老年代，回收後沒變或者更大, 0.0003862 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 496K->0K(2560K)] [ParOldGen: 6106K->5014K(7168K)] 6602K->5014K(9728K), [Metaspace: 3439K->3439K(1056768K)], 0.0031555 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 0K->0K(1536K)] 5014K->5014K(8704K), 0.0003299 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 0K->0K(1536K)] [ParOldGen: 5014K->4912K(7168K)] 5014K->4912K(8704K), [Metaspace: 3439K->3439K(1056768K)], 0.0055557 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
遍歷次數為：16
Heap
 PSYoungGen      total 1536K, used 59K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 1024K, 5% used [0x00000000ffd00000,0x00000000ffd0ef18,0x00000000ffe00000)
  from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 7168K, used 4912K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 68% used [0x00000000ff600000,0x00000000ffacc2f8,0x00000000ffd00000)
 Metaspace       used 3473K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 371K, capacity 388K, committed 512K, reserved 1048576K

Close-DoEscapeAnalysis，不開意味著都在堆空間開闢空間 -XX: PrintEscapeAnalysis 查看逃逸分析的篩選結果

如何快速的判斷是否發生了逃逸分析，大家就看new的物件實體是否有可能在方法外被調用

public EscapeAnalysis obj;  
  
/*  
方法返回EscapeAnalysis物件，發生逃逸  
 */  
public EscapeAnalysis getInstance(){  
    return obj == null? new EscapeAnalysis() : obj; 
}  
/*  
為成員屬性賦值，發生逃逸  
 */  
public void setObj(){  
    this.obj = new EscapeAnalysis();  
}  
//思考：如果當前的obj引用聲明為static What about it? Escape still occurs.  
  
/*  
The scope of the object is valid only within the current method, so no escape occurs.  
 */  
public void useEscapeAnalysis(){  
    EscapeAnalysis e = new EscapeAnalysis();  
}  
/*  
The value of the referenced member variable causes escape.  
 */  
public void useEscapeAnalysis1(){  
    EscapeAnalysis e = getInstance();  
    //getInstance().xxx()Escape also occurs.  
}

Optimization cannot be 100 percent complete, and some cases will always remain unoptimized on the stack.

關閉逃逸分析:-DoEscapeAnalysis,未發生逃逸時,會有1千萬個User物件,且發生GC

開啟後,不會發生GC,只有10萬User物件

-Xmx1G -Xms1G -XX:-DoEscapeAnalysis -XX:+PrintGCDetails

public class StackAllocation {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();

        for (int i = 0; i < 10000000; i++) {
            alloc();
        }
        // 查看執行時間
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为： " + (end - start) + " ms");
        // 為了方便查看堆記憶體中物件個數, 執行緒sleep
        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
    }

    private static void alloc() {
        User user = new User();
        //關閉逃逸分析:-DoEscapeAnalysis,未發生逃逸時,會有1千萬個User物件,and occurs GC
        //after enabling,does not occur GC,only 10 ten thousand User object
    }

    static class User {
    }
}

未發生逃逸的 aggregate 經過 JIT 分析, 會被替換為 純量，不再需要建立物件，大幅減少堆積記憶體的占用

目前類別的完整資訊

class 檔案資訊 class 常數池

都算是符號引用，真正執行符號引用會轉換為直接引用

判斷類別是否載入 new 方法區把類別載入,堆開闢空間,此時類別已經確定

① 載入類別元資訊 ② 為物件分配記憶體(和清除演算法有關) ③ 處理並行問題 ④ 屬性的預設初始化（零值初始化）
⑤ 設定物件頭的資訊 ⑥ 屬性的顯式初始化、程式碼區塊中初始化、建構子中初始化

1. 
2. 規整,指標碰撞:有個指標指向空閒和使用的分界處 不規整:空閒列表法 id,name,account 都是在 init 中執行的 Java SE/4.面对对象编程/3.面向对象下/4.代码块#1 3 程序中成员变量赋值的执行顺序

public class Customer{  
    int id = 1001;  
    String name;  
    Account acct;  
    {  
        name = "匿名客户";  
    }  
    public Customer(){  
        acct = new Account();  
    }  
  
}
class Account{  
  
}

public class CustomerTest {  
    public static void main(String[] args) {  
        Customer cust = new Customer();  
    }  
}

• 機器碼 機器碼-->指令-->指令集-->組合語言---> 高階語言

HotSpot 會自己選擇使用解譯器還是使用編譯器 Jit 將程式碼編譯且快取起來了，比解譯器快，而解譯器回應速度快

由於還沒有進行熱點程式碼統計和 JIT 動態編譯

超過這個閾值的才會被 cache

• 熱度衰減

• HotSpot VM 中 JIT 分類

• AOT 編譯器 (-->.so) (linux64 支援)

官網

存在循環引用問題

導致 3 個沒有被 GC, 其實已經不需要了

一致性 : 不在物件引用動態變化進行判斷，必須 Stop the world

• 兩次標記

手動重寫的 finalize 方法，與引用鏈上的任意一個物件建立了聯繫

public class CanReliveObj {  
    public static CanReliveObj obj;//類變數，屬於 GC Root  
  
    //此方法只能被呼叫一次  
    @Override  
    protected void finalize() throws Throwable {  
        System.out.println("调用当前类重写的finalize()方法");  
        obj = this;//當前待回收的物件在finalize()方法中與引用鏈上的一個物件obj建立了聯繫  
    }  
  
  
    public static void main(String[] args) {  
        try {  
            obj = new CanReliveObj();  
            // 物件第一次成功拯救自己  
            obj = null;  
            System.gc();//呼叫垃圾回收器,呼叫了重寫的finalize, obj = this,建立了聯繫  
            System.out.println("第1次 gc");  
            // 因為Finalizer執行緒優先級很低，暫停2秒，以等待它  
            Thread.sleep(2000);  
            if (obj == null) {  
                System.out.println("obj is dead");  
            } else {  
                System.out.println("obj is still alive");  
            }  
  
  
            System.out.println("第2次 gc");  
            // 下面這段程式碼與上面的完全相同，但是這次自救卻失敗了  
            obj = null;  
            System.gc();  
            // 因為Finalizer執行緒優先級很低，暫停2秒，以等待它  
            Thread.sleep(2000);  
            if (obj == null) {  
                System.out.println("obj is dead");  
            } else {  
                System.out.println("obj is still alive");  
            }  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

綠色是可達到的物件，黑色是發現沒有被標記的

stop the world

空閒列表（放入新的如果不夠可以放入老年代空閒空間）

如果大部分都是存活物件時效率會很差，但一般新生代一次都可以回收 70% 到 99% 的記憶體空間

指標碰撞

• Incremental collection algorithm

• Partition algorithm

//will not GC
public void localvarGC1() {  
    byte[] buffer = new byte[10 * 1024 * 1024];//10MB  
    System.gc();  
}  

  //buffer be collected
public void localvarGC2() {  
    byte[] buffer = new byte[10 * 1024 * 1024];  
    buffer = null;  
    System.gc();  
}  

//buffer was not collected,because no object needs to occupy buffer the location of slot slot, does not need to be collected, but the bytecode will not display
![[assets/上内存与垃圾回收/image-20240106195523072.png]]
public void localvarGC3() {  
    {  
        byte[] buffer = new byte[10 * 1024 * 1024];  
    }  
    System.gc();  
}  

//at this time buffer will be collected,value will occupy the previous buffer of the slot slot, which causes the original reference to no longer exist, and the original data is GC collected
public void localvarGC4() {  
    {  
        byte[] buffer = new byte[10 * 1024 * 1024];  
    }  
    int value = 10;  
    System.gc();  
}  


public void localvarGC5() {  
    localvarGC1();  
    System.gc();  
}  

// after the method call is finished, then GC can be collected
public static void main(String[] args) {  
    LocalVarGC local = new LocalVarGC();  
    local.localvarGC5();  
}

忘記斷開一個參考導致存在記憶體洩漏

• 平行

• 並行

此時有一個軟參考,一個強參考

public class PhantomReferenceExample {
    public static void main(String[] args) throws InterruptedException {
        // 建立一個參考佇列
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();

        // 建立一個物件並將其包裝在虛參考中
        Object obj = new Object();
        PhantomReference<Object> phantomReference = new PhantomReference<>(obj, referenceQueue);

        // Clear strong references and allow the object to be garbage collected
        obj = null;

        // Force garbage collection to run
        System.gc();

        // Wait for a period of time to ensure the garbage collector runs
        Thread.sleep(1000);

        // Check whether the reference queue contains a phantom reference
        if (referenceQueue.poll() != null) {
            System.out.println("对象已被垃圾回收");
        } else {
            System.out.println("对象尚未被垃圾回收");
        }
    }
}

 public class PhantomReferenceTest {  
    public static PhantomReferenceTest obj;//Declaration of the current class object  
    static ReferenceQueue<PhantomReferenceTest> phantomQueue = null;//Reference queue  
  
    public static class CheckRefQueue extends Thread {  
        @Override  
        public void run() {  
            while (true) {  
                if (phantomQueue != null) {  
                    PhantomReference<PhantomReferenceTest> objt = null;  
                    try {  
                        objt = (PhantomReference<PhantomReferenceTest>) phantomQueue.remove();  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                    if (objt != null) {  
                        System.out.println("追踪垃圾回收过程：PhantomReferenceTest实例被GC了");  
                    }  
                }  
            }  
        }  
    }  
  
    @Override  
    protected void finalize() throws Throwable { //finalize()The method can be called only once!  
        super.finalize();  
        System.out.println("调用当前类的finalize()方法");  
        obj = this;  
    }  
  
    public static void main(String[] args) {  
        Thread t = new CheckRefQueue();  
        t.setDaemon(true);//Set as a daemon thread: when the program has no non daemon threads, the daemon thread also finishes running.  
        t.start();  
  
        phantomQueue = new ReferenceQueue<PhantomReferenceTest>();  
        obj = new PhantomReferenceTest();  
        //Constructed the PhantomReferenceTest phantom reference of the object and specified the reference queue  
        PhantomReference<PhantomReferenceTest> phantomRef = new PhantomReference<PhantomReferenceTest>(obj, phantomQueue);  
  
        try {  
            //The object in the phantom reference cannot be obtained  
            System.out.println(phantomRef.get());  
  
            //Remove the strong reference  
            obj = null;  
            //Performed for the first time GC,Because the object can be resurrected,GC the object cannot be collected  
            System.gc();  
            Thread.sleep(1000);  
            if (obj == null) {  
                System.out.println("obj 是 null");  
            } else {  
                System.out.println("obj 可用");  
            }  
            System.out.println("第 2 次 gc");  
            obj = null;  
            System.gc(); //Once the obj object is collected, this phantom reference will be placed into the reference queue.  
            Thread.sleep(1000);  
            if (obj == null) {  
                System.out.println("obj 是 null");  
            } else {  
                System.out.println("obj 可用");  
            }  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

• By thread

• By working mode

JDK14 relationship diagram

Parallel Scavenge has a different underlying implementation and cannot be paired with CMS GC

To ensure that user objects can continue to execute, the address of the object cannot be changed, so compact cannot be used

G1 使用壓縮技術來整理堆積空間。在垃圾回收過程中，G1 會將存活物件移動到堆積中的其他區域，並且盡量減少記憶體碎片化，從而實現記憶體的壓縮。這一步驟類似於標記-清除演算法中的壓縮過程

• 化整為零 G1 垃圾回收器, 新生代老年代在邏輯上不再是連續的了
• region 內部細節 指標在allocated/unallocate分界處

解決了一個物件被不同區域引用的問題 回收年輕代也不得不同時掃描老年代，因為老年代的物件可能引用了新生代的物件 Remembered Set 避免了全局掃描, 而回收老年代則不用擔心年輕代引用了老年代

如果引用的物件是同一個 region 內的就會不記錄

1. 年輕代 GC

1. 併發標記過程

1. 混合回收

複製演算法. 避免了碎片

1. Full GC（可選過程四）

ZGC

參數列表 Young GC Full GC

物件後不下後先進行一次GC，發現s區放不下年輕代中的內容，直接到老年代，4MB的大物件在年輕代能放下了

int num = 10;  
//s1 the declaration is thread safe  
//資料不會在每個堆疊框架之間共享  
public static void method1(){  
    //StringBuilder:執行緒不安全  
    StringBuilder s1 = new StringBuilder();  
    s1.append("a");  
    s1.append("b");  
  
}  
//sBuilder的操作過程：是執行緒不安全的  
//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的操作：是執行緒安全的  
public static String method4(){  
    StringBuilder s1 = new StringBuilder();  
    s1.append("a");  
    s1.append("b");  
    return s1.toString();  
}

總結：當有內部資料的作用域不只在方法內時，就是方法不安全的