窺探JVM內存分配和回收的過程

時間  2019-12-06
標籤 窺探 jvm 內存 分配 回收 過程 欄目 Java 简体版
原文   原文鏈接

1、環境

JDK 垃圾收集器 是否啓用TLAB 通用JVM參數（堆內存分配見下圖）
1.6.0_65 Serial + Serial Old 否 -Xms20m -Xmx20m -Xmn10m -XX:SurvivorRatio=8

圖片失效

2、說明

  • Minor GC
    • 發生在新生代，當Eden區域沒有足夠空間進行分配
    • Java對象大多具備短命的特性
    • Minor GC很是頻繁，速度也比較快
  • Major GC / Full GC
    • 發生在老年代
    • 出現Major GC，常常伴隨至少一次Minor GC
    • SpeedOf (Minor GC) ≈ 10 * SpeedOf (Major GC)

3、示例

1. 對象優先分配在Eden區

1.1 說明
  • 新對象，優先考慮分配在Eden區域
  • 若是Eden區域沒有足夠的空間容納新對象，進行GC
    • 若是老年代有足夠的連續空間用來存儲全部新生代對象（或歷次晉升的平均大小） ⇒ Minor GC
      • 若是對象太大，以致於Survivor區域沒法容納，對象直接晉升到老年代
      • 不然使用複製算法，複製到Survivor區域
    • 不然 ⇒ 先進行一次Minor GC，若仍不知足上述條件，進行Full GC
      • 若Full GC後依然內存不足，
1.2 代碼
# 代碼
public class TestAllocation {
    private static final int _1MB = 1024 * 1024;

    // JVM Args:
    // -XX:+PrintGCDetails
    // -XX:+UseSerialGC
    // -Xms20m -Xmx20m
    // -Xmn10m -XX:SurvivorRatio=8
    public static void main(String[] args) throws InterruptedException {
        System.out.println("===1. start full gc start===");
        System.gc();
        System.out.println("===1. start full gc end===\n");

        System.out.println("===2. gc logs===");
        byte[] a1 = new byte[_1MB / 4];
        byte[] a2 = new byte[4 * _1MB];
        byte[] a3 = new byte[4 * _1MB];// 一次Minor GC
        byte[] a4 = new byte[4 * _1MB];// 一次Minor GC
        byte[] a5 = new byte[4 * _1MB];// 一次Minor GC + 一次Full GC ⇒ OOM
    }
}
1.3 運行結果
# 僅保留關鍵信息

===1. start full gc start===
[Full GC (System) [Tenured: 0K->426K(10240K)] 1974K->426K(19456K)
===1. start full gc end===

===2. gc logs===
[GC [DefNew: 4843K->256K(9216K)] 5270K->4778K(19456K)]
[GC [DefNew: 4352K->256K(9216K)] 8874K->8874K(19456K)]
[GC [DefNew: 4436K->4436K(9216K)][Tenured: 8618K->8618K(10240K)] 13055K->12970K(19456K)
[Full GC [Tenured: 8618K->8549K(10240K)] 12970K->12902K(19456K)

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    
Heap
 def new generation   total 9216K, used 4657K
  eden space 8192K,  56% used
  from space 1024K,   0% used
  to   space 1024K,   0% used
 tenured generation   total 10240K, used 8549K
   the space 10240K,  83% used
1.4 運行示意圖

1.5 運行過程解析
  1. System.gc() ⇒ Full GC
    • 新生代已分配內存：0K
    • 老年代已分配內存：426K
  2. byte[] a1 = new byte[_1MB / 4];
    • Eden空間充足，爲a1分配256K內存
  3. byte[] a2 = new byte[4 * _1MB];
    • Eden空間充足，爲a2分配4096K內存
  4. byte[] a3 = new byte[4 * _1MB];
    • Eden空間不足，不能爲a3分配4096K內存,須要進行GC
      • 4.1 斷定是否須要Full GC
        • 老年代未分配的連續空間：10240-427 = 9813K
        • 全部的新生代對象：sizeof(a1)+size(a2)=256+4096 = 4352K
        • 9813 ≫ 4352 ⇒ Minor GC
      • 4.2 進行Minor GC
        • 1024 > 256 ⇒ remainingSpaceOf(Survivor) > sizeof(a1) ⇒ a1複製到to（Survivor區）
        • 4096 > 1024 ⇒ sizeof(a2) > sizeof(Survivor) ⇒ a2晉升到Tenured區
      • 4.3 Minor GC以後，Eden空間充足，爲a3分配4096K內存
        • 新生代 - 4352K
          • Eden：4096K(a3)
          • from(Survivor)：256K(a1)
          • to(Survivor)：0K
        • 老年代 - 4522K
          • Tenured：426K + 4096K(a2)
  5. byte[] a4 = new byte[4 * _1MB];
    • Eden空間不足，不能爲a4分配4096K內存,須要進行GC
      • 5.1 斷定是否須要Full GC
        • 老年代未分配的連續空間：10240-427-4096 = 5717K
        • 全部的新生代對象：sizeof(a1)+size(a2)=256+4096 = 4352K
        • 5717 ≫ 4352 ⇒ Minor GC
      • 5.2 進行Minor GC
        • 第二次GC ⇒ a1由from複製到to
        • 4096 > 1024 ⇒ sizeof(a3) > sizeof(Survivor) ⇒ a3晉升到Tenured區
      • 5.3 Minor GC以後，Eden空間充足，爲a4分配4096K內存
        • 新生代 - 4436K
          • Eden：84K + 4096K(a4)
          • from(Survivor)：0K
          • to(Survivor)：256K(a1)
        • 老年代 - 8618K
          • Tenured：426K + 4096K(a2) + 4096K(a3)
  6. byte[] a5 = new byte[4 * _1MB];
    • Eden空間不足，不能爲a5分配4096K內存,須要進行GC
      • 6.1 斷定是否須要Full GC
        • 老年代未分配的連續空間：10240-427-4096-4096 = 1621K
        • 全部的新生代對象：sizeof(a1)+size(a2)=256+4096 = 4352K
        • 1621 ≪ 4352 ⇒ Minor GC + Full GC
      • 6.2 進行Minor GC
        • 第三次GC ⇒ a1由to複製到from
        • 4096 > 1621 ⇒ sizeof(a4) > remainingSpaceOf(Tenured) ⇒ a4沒法晉升到Tenured區
      • 6.3 Minor GC以後，堆空間內存佈局沒有變化，Eden空間依舊不足，進行Full GC
        • 老年代減小了69K，忽略不計，依然保留着a2和a3
        • 新生代增長了17k，忽略不計，依然保留着a1和a4
      • 6.4 Full GC以後，新生代和老年代內存都不足覺得a5分配內存，拋出OOM異常

2. 大對象直接進入老年代

2.1 說明
  • 大對象：須要大量連續內存空間的Java對象，如長字符串和大數組
    • 代碼中儘可能避免使用短命大對象
  • -XX:PretenureSizeThreshold=?(Byte)
    • 新對象的大小大於PretenureSizeThreshold，直接分配在老年代
    • 做用
      • 新生代採用的是複製算法，避免Eden和Survivor之間的內存複製
      • 下降GC頻率
2.2 代碼
 
public class TestPretenureSizeThreshold {
    private static final int _1MB = 1024 * 1024;

    // JVM Args
    // -XX:+PrintGCDetails
    // -XX:+UseSerialGC
    // -Xms20m -Xmx20m
    // -Xmn10m -XX:SurvivorRatio=8
    // -XX:PretenureSizeThreshold=3145728
    public static void main(String[] args) {
        byte[] a1 = new byte[4 * _1MB]; // 直接分配到tenured
        byte[] a2 = new byte[4 * _1MB]; // 直接分配到tenured,無需GC
    }
}
2.3 運行結果
# 僅保留關鍵信息

Heap
 def new generation   total 9216K, used 2302K
  eden space 8192K,  28% used
  from space 1024K,   0% used
  to   space 1024K,   0% used
 tenured generation   total 10240K, used 8192K
   the space 10240K,  80% used
2.4 運行過程解析
  • sizeof(a1) > PretenureSizeThreshold ⇒ 直接分配在Tenured
  • sizeof(a2) > PretenureSizeThreshold ⇒ 直接分配在Tenured
    • 若是不設置PretenureSizeThreshold，在分配a2前會產生一次Minor GC，最終a1在Tenured，a2在Eden

3. 長期存活的對象晉升到老年代

3.1 說明
  • 對象年齡：對象每經歷一次Minor GC，對象年齡加1
  • JVM參數：-XX:MaxTenuringThreshold=？，默認是15
3.2 代碼
public class TestTenuringThreshold {
    private static final int _1MB = 1024 * 1024;
    private static final int MAX_OBJ_AGE = 2;

    // JVM Args
    // -XX:+PrintGCDetails
    // -XX:+UseSerialGC
    // -Xms20m -Xmx20m
    // -Xmn10m -XX:SurvivorRatio=8
    // -XX:MaxTenuringThreshold=3
    public static void main(String[] args) {
        System.out.println("===1. start full gc start===");
        System.gc();
        System.out.println("===1. start full gc end===\n");

        System.out.println("===2. gc logs===");
        byte[] a1 = new byte[_1MB / 4];
        byte[] a2 = new byte[4 * _1MB];
        byte[] a3 = null;
        for (int i = 0; i < MAX_OBJ_AGE; ++i) {
            // 執行一次, a1的年齡加1 , 最終a1的年齡爲MAX_OBJ_AGE
            // 若是 MAX_OBJ_AGE > MaxTenuringThreshold ⇒ a1 晉升到 Tenured
            // 若是 MAX_OBJ_AGE ≦ MaxTenuringThreshold ⇒ a1 停留在 Survivor
            a3 = null;
            a3 = new byte[4 * _1MB];
        }
    }
}
3.3 運行結果
# 僅保留關鍵信息

# MAX_OBJ_AGE = 3時
===1. start full gc start===
[Full GC (System) [Tenured: 0K->430K(10240K)] 1974K->430K(19456K)
===1. start full gc end===

===2. gc logs===
[GC [DefNew: 4679K->256K(9216K)] 5110K->4783K(19456K)]
[GC [DefNew: 4352K->256K(9216K)] 8879K->4783K(19456K)]
[GC [DefNew: 4352K->256K(9216K)] 8879K->4783K(19456K)]
Heap
 def new generation   total 9216K, used 4516K
  eden space 8192K,  52% used
  from space 1024K,  25% used
  to   space 1024K,   0% used
 tenured generation   total 10240K, used 4526K
   the space 10240K,  44% used




# MAX_OBJ_AGE = 4時
===1. start full gc start===
[Full GC (System) [Tenured: 0K->426K(10240K)] 1974K->426K(19456K)
===1. start full gc end===

===2. gc logs===
[GC [DefNew: 4843K->256K(9216K)] 5270K->4779K(19456K)]
[GC [DefNew: 4437K->256K(9216K)] 8960K->4779K(19456K)]
[GC [DefNew: 4409K->257K(9216K)] 8931K->4780K(19456K)]
[GC [DefNew: 4391K->0K(9216K)] 8913K->4780K(19456K)]
Heap
 def new generation   total 9216K, used 4449K
  eden space 8192K,  54% used
  from space 1024K,   0% used
  to   space 1024K,   0% used
 tenured generation   total 10240K, used 4779K
   the space 10240K,  46% used
3.4 運行過程解析
  • a1和a2如今Eden分配內存
  • 第一次爲a3分配內存時，必須進行Minor GC，a2被晉升Tenured，a3分配在Eden，a1被複制到from（Survivor），此時a1的對象年齡爲1
    • 隨後每次循環中，先將a3置爲null，a3原先引用的內存變成了垃圾，後續可回收
    • 再次爲a3分配內存，此時Eden區內存不足，進行Minor GC
      • 目前存活的對象僅僅是a1,將其複製到to（另外一塊Survivor），a1的對象年齡加1
      • 將from和Eden區清空，並在Eden爲a3分配內存
  • MAX_OBJ_AGE = 3 ≦ MaxTenuringThreshold時
    • from space 1024K, 25% used ⇒ a1依舊停留在Survivor
  • MAX_OBJ_AGE = 4 > MaxTenuringThreshold時
    • [GC [DefNew: 4391K->0K(9216K)] 8913K->4780K(19456K)] ⇒ a1晉升到Tenured
    • from space 1024K, 0% used ⇒ Survivor已經無存活對象

4. 動態對象年齡斷定

4.1 說明
  • 在Survivor中相同年齡（對象年齡 ≧ 2）的全部對象大小之和 ≧ 0.5 * sizeof(Survivor) ⇒ 大於或等於該年齡的對象直接晉升到老年代，無須考慮MaxTenuringThreshold
4.2 代碼一（單個1/2對象）
public class TestDynamicObjectAge {
    private static final int _1MB = 1024 * 1024;
    private static final int MAX_OBJ_AGE = 1;

    // JVM Args
    // -XX:+PrintGCDetails
    // -XX:+UseSerialGC
    // -Xms20m -Xmx20m
    // -Xmn10m -XX:SurvivorRatio=8
    // -XX:MaxTenuringThreshold=3
    public static void main(String[] args) {
        int al;
        System.out.println("===1. start full gc start===");
        System.gc();
        System.out.println("===1. start full gc end===\n");

        System.out.println("===2. gc logs===");
        byte[] a1 = new byte[_1MB / 2]; # 單個1/2對象
        byte[] a2 = new byte[4 * _1MB];
        byte[] a3 = null;
        for (int i = 0; i < MAX_OBJ_AGE; ++i) {
            // 相同年齡（對象年齡 ≧ 2）的全部對象大小之和 ≧ 0.5 * sizeof(Survivor)
            // ⇒ 大於或等於該年齡的對象直接晉升到老年代，無需考慮MaxTenuringThreshold
            a3 = null;
            a3 = new byte[4 * _1MB];
        }
    }
}
4.3 代碼一運行結果
# 僅保留關鍵信息

# MAX_OBJ_AGE = 1時
===1. start full gc start===
[Full GC (System) [Tenured: 0K->429K(10240K)] 1974K->429K(19456K)
===1. start full gc end===

===2. gc logs===
[GC [DefNew: 5099K->513K(9216K)] 5529K->5039K(19456K)]
Heap
 def new generation   total 9216K, used 4773K
  eden space 8192K,  52% used
  from space 1024K,  50% used # a1的對象年齡爲1，依舊停留在Survivor區域
  to   space 1024K,   0% used
 tenured generation   total 10240K, used 4525K
   the space 10240K,  44% used




# MAX_OBJ_AGE = 2時
===1. start full gc start===
[Full GC (System) [Tenured: 0K->426K(10240K)] 1974K->426K(19456K)
===1. start full gc end===

===2. gc logs===
[GC [DefNew: 5099K->513K(9216K)] 5526K->5036K(19456K)]
[GC [DefNew: 4694K->1K(9216K)] 9216K->5037K(19456K)] 
# a1的對象年齡爲2 < MaxTenuringThreshold，且a2等於0.5 * sizeof(Survivor)，直接晉升到老年代
Heap
 def new generation   total 9216K, used 4317K
  eden space 8192K,  52% used
  from space 1024K,   0% used 
  # a1的對象年齡爲2 < MaxTenuringThreshold，且a2等於0.5 * sizeof(Survivor)，直接晉升到老年代
  to   space 1024K,   0% used
 tenured generation   total 10240K, used 5036K
   the space 10240K,  49% used
4.4 代碼二（四個1/8對象）
public class TestDynamicObjectAge {
    private static final int _1MB = 1024 * 1024;
    private static final int MAX_OBJ_AGE = 1;

    // JVM Args
    // -XX:+PrintGCDetails
    // -XX:+UseSerialGC
    // -Xms20m -Xmx20m
    // -Xmn10m -XX:SurvivorRatio=8
    // -XX:MaxTenuringThreshold=3
    public static void main(String[] args) {
        int al;
        System.out.println("===1. start full gc start===");
        System.gc();
        System.out.println("===1. start full gc end===\n");

        System.out.println("===2. gc logs===");
        byte[] a1_1 = new byte[_1MB / 8]; # 四個1/8對象
        byte[] a1_2 = new byte[_1MB / 8];
        byte[] a1_3 = new byte[_1MB / 8];
        byte[] a1_4 = new byte[_1MB / 8];
        byte[] a2 = new byte[4 * _1MB];
        byte[] a3 = null;
        for (int i = 0; i < MAX_OBJ_AGE; ++i) {
            // 相同年齡（對象年齡 ≧ 2）的全部對象大小之和 ≧ 0.5 * sizeof(Survivor)
            // ⇒ 大於或等於該年齡的對象直接晉升到老年代，無需考慮MaxTenuringThreshold
            a3 = null;
            a3 = new byte[4 * _1MB];
        }
    }
}
4.5 代碼二運行結果
# 僅保留關鍵信息

# MAX_OBJ_AGE = 1時
===1. start full gc start===
[Full GC (System) [Tenured: 0K->427K(10240K)] 1974K->427K(19456K)
===1. start full gc end===

===2. gc logs===
[GC [DefNew: 4971K->514K(9216K)] 5399K->5038K(19456K)]
Heap
 def new generation   total 9216K, used 4859K
  eden space 8192K,  53% used # a1_一、a1_二、a1_三、a1_4的對象年齡爲1，依舊停留在Survivor區域
  from space 1024K,  50% used
  to   space 1024K,   0% used
 tenured generation   total 10240K, used 4523K
   the space 10240K,  44% used




# MAX_OBJ_AGE = 2時
===1. start full gc start===
[Full GC (System) [Tenured: 0K->427K(10240K)] 1974K->427K(19456K)
===1. start full gc end===

===2. gc logs===
[GC [DefNew: 4971K->514K(9216K)] 5399K->5037K(19456K)]
[GC [DefNew: 4694K->0K(9216K)] 9218K->5037K(19456K)]
# a1_一、a1_二、a1_3和a1_4的對象年齡爲2 < MaxTenuringThreshold，且它們之和等於0.5 * sizeof(Survivor)，晉升到老年代
Heap
 def new generation   total 9216K, used 4316K
  eden space 8192K,  52% used
  from space 1024K,   0% used
  # a1_一、a1_二、a1_3和a1_4的對象年齡爲2 < MaxTenuringThreshold，且它們之和等於0.5 * sizeof(Survivor)，晉升到老年代
  to   space 1024K,   0% used
 tenured generation   total 10240K, used 5037K
   the space 10240K,  49% used
 compacting perm gen  total 21248K, used 4965K
   the space 21248K,  23% used

3、參考資料

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程