永遠不要使用雙花括號初始化例項,否則就會OOM!

Java中文社群發表於2020-05-22

生活中的尷尬無處不在,有時候你只是想簡單的裝一把,但某些“老同志”總是在不經意之間,給你無情的一腳,踹得你簡直無法呼吸。

但誰讓我們年輕呢?吃虧要趁早,前路會更好。

喝了這口溫熱的雞湯之後,我們們來聊聊是怎麼回事。

事情是這樣的,在一個不大不小的專案中,小王寫下了這段程式碼:

Map<String, String> map = new HashMap() {{
    put("map1", "value1");
    put("map2", "value2");
    put("map3", "value3");
}};
map.forEach((k, v) -> {
    System.out.println("key:" + k + " value:" + v);
});

本來是用它來替代下面這段程式碼的:

Map<String, String> map = new HashMap();
map.put("map1", "value1");
map.put("map2", "value2");
map.put("map3", "value3");
map.forEach((k, v) -> {
    System.out.println("key:" + k + " value:" + v);
});

兩塊程式碼的執行結果也是完全一樣的:

key:map3 value:value3

key:map2 value:value2

key:map1 value:value1

所以小王正在得意的把這段程式碼介紹給部門新來的妹子小甜甜看,卻不巧被正在經過的老張也看到了。

老張本來只是想給昨天的枸杞再續上一杯 85° 的熱水,但說來也巧,剛好撞到了一次能在小甜甜面前秀技術的一波機會,於是習慣性的整理了一下自己稀疏的秀髮,便開啟了 diss 模式。

img

“小王啊,你這個程式碼問題很大啊!”

“怎麼能用雙花括號初始化例項呢?”

此時的小王被問的一臉懵逼,內心有無數個草泥馬奔騰而過,心想你這頭老牛竟然也和我爭這顆嫩草,但內心卻有一種不祥的預感,感覺自己要輸,瞬間羞澀的不知該說啥,只能紅著小臉,輕輕的“嗯?”了一聲。

老張:“使用雙花括號初始化例項是會導致記憶體溢位的啦!儂不曉得嘛?”

小王沉默了片刻,只是憑藉著以往的經驗來看,這“老傢伙”還是有點東西的,於是敷衍的“哦~”了一聲,彷彿自己明白了怎麼回事一樣,,其實內心仍然迷茫的一匹,為了不讓其他同事發現,只得這般作態。

於是片刻的敷衍,待老張離去之後,才悄悄的開啟了 Google,默默的搜尋了一下。

小王:哦,原來如此......

雙花括號初始化分析

首先,我們來看使用雙花括號初始化的本質是什麼?

以我們這段程式碼為例:

Map<String, String> map = new HashMap() {{
    put("map1", "value1");
    put("map2", "value2");
    put("map3", "value3");
}};

這段程式碼其實是建立了匿名內部類,然後再進行初始化程式碼塊

這一點我們可以使用命令 javac 將程式碼編譯成位元組碼之後發現,我們發現之前的一個類被編譯成兩個位元組碼(.class)檔案,如下圖所示:

img

我們使用 Idea 開啟 DoubleBracket$1.class 檔案發現:

import java.util.HashMap;

class DoubleBracket$1 extends HashMap {
    DoubleBracket$1(DoubleBracket var1) {
        this.this$0 = var1;
        this.put("map1", "value1");
        this.put("map2", "value2");
    }
}

此時我們可以確認,它就是一個匿名內部類。那麼問題來了,匿名內部類為什麼會導致記憶體溢位呢?

匿名內部類的“鍋”

在 Java 語言中非靜態內部類會持有外部類的引用,從而導致 GC 無法回收這部分程式碼的引用,以至於造成記憶體溢位。

思考 1:為什麼要持有外部類?

這個就要從匿名內部類的設計說起了,在 Java 語言中,非靜態匿名內部類的主要作用有兩個。

1、當匿名內部類只在外部類(主類)中使用時,匿名內部類可以讓外部不知道它的存在,從而減少了程式碼的維護工作。

2、當匿名內部類持有外部類時,它就可以直接使用外部類中的變數了,這樣可以很方便的完成呼叫,如下程式碼所示:

public class DoubleBracket {
    private static String userName = "磊哥";
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Map<String, String> map = new HashMap() {{
            put("map1", "value1");
            put("map2", "value2");
            put("map3", "value3");
            put(userName, userName);
        }};
    }
}

從上述程式碼可以看出在 HashMap 的方法內部,可以直接使用外部類的變數 userName

思考 2:它是怎麼持有外部類的?

關於匿名內部類是如何持久外部物件的,我們可以通過檢視匿名內部類的位元組碼得知,我們使用 javap -c DoubleBracket\$1.class 命令進行檢視,其中 $1 為以匿名類的位元組碼,位元組碼的內容如下;

javap -c DoubleBracket\$1.class
Compiled from "DoubleBracket.java"
class com.example.DoubleBracket$1 extends java.util.HashMap {
  final com.example.DoubleBracket this$0;

  com.example.DoubleBracket$1(com.example.DoubleBracket);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:Lcom/example/DoubleBracket;
       5: aload_0
       6: invokespecial #7                  // Method java/util/HashMap."<init>":()V
       9: aload_0
      10: ldc           #13                 // String map1
      12: ldc           #15                 // String value1
      14: invokevirtual #17                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
      17: pop
      18: aload_0
      19: ldc           #21                 // String map2
      21: ldc           #23                 // String value2
      23: invokevirtual #17                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
      26: pop
      27: return
}

其中,關鍵程式碼的在 putfield 這一行,此行表示有一個對 DoubleBracket 的引用被存入到 this$0 中,也就是說這個匿名內部類持有了外部類的引用。

如果您覺得以上位元組碼不夠直觀,沒關係,我們用下面的實際的程式碼來證明一下:

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class DoubleBracket {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Map map = new DoubleBracket().createMap();
        // 獲取一個類的所有欄位
        Field field = map.getClass().getDeclaredField("this$0");
        // 設定允許方法私有的 private 修飾的變數
        field.setAccessible(true);
        System.out.println(field.get(map).getClass());
    }
    public Map createMap() {
        // 雙花括號初始化
        Map map = new HashMap() {{
            put("map1", "value1");
            put("map2", "value2");
            put("map3", "value3");
        }};
        return map;
    }
}

當我們開啟除錯模式時,可以看出 map 中持有了外部物件 DoubleBracket,如下圖所示:

img

以上程式碼的執行結果為:

class com.example.DoubleBracket

從以上程式輸出結果可以看出:匿名內部類持有了外部類的引用,因此我們才可以使用 $0 正常獲取到外部類,並輸出相關的類資訊

什麼情況會導致記憶體洩漏?

當我們把以下正常的程式碼:

public void createMap() {
    Map map = new HashMap() {{
        put("map1", "value1");
        put("map2", "value2");
        put("map3", "value3");
    }};
    // 業務處理....
}

改為下面這個樣子時,可能會造成記憶體洩漏:

public Map createMap() {
    Map map = new HashMap() {{
        put("map1", "value1");
        put("map2", "value2");
        put("map3", "value3");
    }};
    return map;
}

為什麼用了「可能」而不是「一定」會造成記憶體洩漏?

img

這是因為當此 map 被賦值為其他類屬性時,可能會導致 GC 收集時不清理此物件,這時候才會導致記憶體洩漏。可以關注我「Java中文社群」後面會專門寫一篇關於此問題的文章。

如何保證記憶體不洩露?

要想保證雙花扣號不洩漏,辦法也很簡單,只需要將 map 物件宣告為 static 靜態型別的就可以了,程式碼如下:

public static Map createMap() {
    Map map = new HashMap() {{
        put("map1", "value1");
        put("map2", "value2");
        put("map3", "value3");
    }};
    return map;
}

什麼?你不相信!

img

沒關係,我們用事實說話,使用以上程式碼,我們重新編譯一份位元組碼,檢視匿名類的內容如下:

javap -c  DoubleBracket\$1.class
Compiled from "DoubleBracket.java"
class com.example.DoubleBracket$1 extends java.util.HashMap {
  com.example.DoubleBracket$1();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/util/HashMap."<init>":()V
       4: aload_0
       5: ldc           #7                  // String map1
       7: ldc           #9                  // String value1
       9: invokevirtual #11                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
      12: pop
      13: aload_0
      14: ldc           #17                 // String map2
      16: ldc           #19                 // String value2
      18: invokevirtual #11                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
      21: pop
      22: aload_0
      23: ldc           #21                 // String map3
      25: ldc           #23                 // String value3
      27: invokevirtual #11                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
      30: pop
      31: return
}

從這次的程式碼我們可以看出,已經沒有 putfield 關鍵字這一行了,也就是說靜態匿名類不會持有外部物件的引用了

為什麼靜態內部類不會持有外部類的引用?

原因其實很簡單,因為匿名內部類是靜態的之後,它所引用的物件或屬性也必須是靜態的了,因此就可以直接從 JVM 的 Method Area(方法區)獲取到引用而無需持久外部物件了。

雙花括號的替代方案

即使宣告為靜態的變數可以避免記憶體洩漏,但依舊不建議這樣使用,為什麼呢?

原因很簡單,專案一般都是需要團隊協作的,假如那位老兄在不知情的情況下把你的 static 給刪掉呢?這就相當於設定了一個隱形的“坑”,其他不知道的人,一不小心就跳進去了,所以我們可以嘗試一些其他的方案,比如 Java8 中的 Stream API 和 Java9 中的集合工廠等。

替代方案 1:Stream

使用 Java8 中的 Stream API 替代,示例如下。原始碼:

List<String> list = new ArrayList() {{
    add("Java");
    add("Redis");
}};

替代程式碼:

List<String> list = Stream.of("Java", "Redis").collect(Collectors.toList());

替代方案 2:集合工廠

使用集合工廠的 of 方法替代,示例如下。原始碼:

Map map = new HashMap() {{
    put("map1", "value1");
    put("map2", "value2");
}};

替代程式碼:

Map map = Map.of("map1", "Java", "map2", "Redis");

顯然使用 Java9 中的方案非常適合我們,簡單又酷炫,只可惜我們還在用 Java 6...6...6... 心碎了一地。

img

總結

本文我們講了雙花括號初始化因為會持有外部類的引用,從而可以會導致記憶體洩漏的問題,還從位元組碼以及反射的層面演示了這個問題。

要想保證雙花括號初始化不會出現記憶體洩漏的辦法也很簡單,只需要被 static 修飾即可,但這樣做還是存在潛在的風險,可能會被某人不小心刪除掉,於是我們另尋它道,發現了可以使用 Java8 中的 Stream 或 Java9 中的集合工廠 of 方法替代“{{”。

最後的話

原創不易,點個「」再走唄!

參考 & 鳴謝

https://www.ripjava.com/article/1291630596325408

https://cloud.tencent.com/developer/article/1179625

https://hacpai.com/article/1498563483898

相關文章