本來想用“{{”秀一波，結果卻導致了內存溢出！

這是我的第 200 期分享

作者 | 王磊

來源 | Java中文社羣（ID：javacn666）

轉載請聯繫授權（微信ID：GG_Stone）

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

但誰讓咱年輕呢？吃虧要趁早，前路會更好。

喝了這口溫熱的雞湯，咱們來聊聊是怎麼回事。

事情是這樣的，在一個不大不小的項目中，小王寫下了這段代碼：

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 模式。

“小王啊，你這個代碼問題很大啊！”

“怎麼能用雙花括號初始化實例呢？”

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

老張：“使用雙花括號初始化實例是會導致內存溢出的啦！儂不曉得嘛？”

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

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

小王：哦，原來如此......

雙花括號初始化分析

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

以我們這段代碼爲例：

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

這段代碼其實是創建了匿名內部類，然後再進行初始化代碼塊。

這一點我們可以使用命令 javac 將代碼編譯成字節碼之後發現，我們發現之前的一個類被編譯成兩個字節碼（.class）文件，如下圖所示：

我們使用 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，如下圖所示：

以上代碼的執行結果爲：

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;
}

爲什麼用了「可能」而不是「一定」會造成內存泄漏？

這是因爲當此 map 被賦值爲其他類屬性時，可能會導致 GC 收集時不清理此對象，這時候纔會導致內存泄漏。可以關注我「Java中文社羣」後面會專門寫一篇關於此問題的文章。

如何保證內存不泄露？

要想保證雙花扣號不泄漏，辦法也很簡單，只需要將 map 對象聲明爲 static 靜態類型的就可以了，代碼如下：

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

什麼？你不相信！

沒關係，我們用事實說話，使用以上代碼，我們重新編譯一份字節碼，查看匿名類的內容如下：

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... 心碎了一地。

總結

本文我們講了雙花括號初始化因爲會持有外部類的引用，從而可以會導致內存泄漏的問題，還從字節碼以及反射的層面演示了這個問題。

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

最後的話

看在我努力編故事的份上，點個「在看」再走唄！

參考 & 鳴謝

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

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

https://hacpai.com/article/1498563483898

往期推薦

if快還是switch快？解密switch背後的祕密

HashMap 的 7 種遍歷方式與性能分析！「修正篇」

關注公衆號發送”進羣“，磊哥拉你進讀者羣。