永遠不要使用雙花括號初始化例項，否則就會OOM！
阿新 • • 發佈：2020-05-22
生活中的尷尬無處不在，有時候你只是想簡單的裝一把，但某些“老同志”總是在不經意之間，給你無情的一腳，踹得你簡直無法呼吸。
但誰讓咱年輕呢？吃虧要趁早，前路會更好。
喝了這口溫熱的雞湯之後，咱們來聊聊是怎麼回事。
事情是這樣的，在一個不大不小的專案中，小王寫下了這段程式碼：
```java
Map map = new HashMap() {{
put("map1", "value1");
put("map2", "value2");
put("map3", "value3");
}};
map.forEach((k, v) -> {
System.out.println("key:" + k + " value:" + v);
});
```
本來是用它來替代下面這段程式碼的：
```java
Map 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，默默的搜尋了一下。
小王：哦，原來如此......
## 雙花括號初始化分析
首先，我們來看使用雙花括號初始化的本質是什麼？
以我們這段程式碼為例：
```java
Map map = new HashMap() {{
put("map1", "value1");
put("map2", "value2");
put("map3", "value3");
}};
```
這段程式碼**其實是建立了匿名內部類，然後再進行初始化程式碼塊**。
這一點我們可以使用命令 `javac` 將程式碼編譯成位元組碼之後發現，我們發現之前的一個類被編譯成兩個位元組碼（.class）檔案，如下圖所示：
我們使用 Idea 開啟 `DoubleBracket$1.class` 檔案發現：
```java
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**、當匿名內部類持有外部類時，它就可以直接使用外部類中的變量了，這樣可以很方便的完成呼叫，如下程式碼所示：
```java
public class DoubleBracket {
private static String userName = "磊哥";
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
Map map = new HashMap() {{
put("map1", "value1");
put("map2", "value2");
put("map3", "value3");
put(userName, userName);
}};
}
}
```
從上述程式碼可以看出在 `HashMap` 的方法內部，可以直接使用外部類的變數 `userName`。
### 思考 2：它是怎麼持有外部類的？
關於匿名內部類是如何持久外部物件的，我們可以通過檢視匿名內部類的位元組碼得知，我們使用 `javap -c DoubleBracket\$1.class` 命令進行檢視，其中 `$1` 為以匿名類的位元組碼，位元組碼的內容如下；
```java
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."":()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` 中，也就是說這個匿名內部類持有了外部類的引用。
如果您覺得以上位元組碼不夠直觀，沒關係，我們用下面的實際的程式碼來證明一下：
```java
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` 正常獲取到外部類，並輸出相關的類資訊**。
## 什麼情況會導致記憶體洩漏？
當我們把以下正常的程式碼：
```java
public void createMap() {
Map map = new HashMap() {{
put("map1", "value1");
put("map2", "value2");
put("map3", "value3");
}};
// 業務處理....
}
```
改為下面這個樣子時，可能會造成記憶體洩漏：
```java
public Map createMap() {
Map map = new HashMap() {{
put("map1", "value1");
put("map2", "value2");
put("map3", "value3");
}};
return map;
}
```
為什麼用了「可能」而不是「一定」會造成記憶體洩漏？
這是因為當此 `map` 被賦值為其他類屬性時，可能會導致 GC 收集時不清理此物件，這時候才會導致記憶體洩漏。可以關注我「Java中文社群」後面會專門寫一篇關於此問題的文章。
## 如何保證記憶體不洩露？
要想保證雙花扣號不洩漏，辦法也很簡單，只需要將 `map` 物件宣告為 `static` 靜態型別的就可以了，程式碼如下：
```java
public static Map createMap() {
Map map = new HashMap() {{
put("map1", "value1");
put("map2", "value2");
put("map3", "value3");
}};
return map;
}
```
什麼？你不相信！
沒關係，我們用事實說話，使用以上程式碼，我們重新編譯一份位元組碼，檢視匿名類的內容如下：
```java
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."":()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 替代，示例如下。原始碼：
```java
List list = new ArrayList() {{
add("Java");
add("Redis");
}};
```
替代程式碼：
```java
List list = Stream.of("Java", "Redis").collect(Collectors.toList());
```
### 替代方案 2：集合工廠
使用集合工廠的 `of` 方法替代，示例如下。原始碼：
```java
Map map = new HashMap() {{
put("map1", "value1");
put("map2", "value2");
}};
```
替代程式碼：
```java
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/14985