生活中的尷尬無處不在,有時候你只是想簡單的裝一把,但某些“老同志”總是在不經意之間,給你無情的一腳,踹得你簡直無法呼吸。
但誰讓我們年輕呢?吃虧要趁早,前路會更好。
喝了這口溫熱的雞湯之後,我們們來聊聊是怎麼回事。
事情是這樣的,在一個不大不小的專案中,小王寫下了這段程式碼:
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