一、驗證
廢話不多說,先上驗證代碼:
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
list.add(i);
}
long lambdaStart = System.currentTimeMillis();
list.forEach(i -> {
// 不用做事情,循環就夠了
});
long lambdaEnd = System.currentTimeMillis();
System.out.println("lambda循環運行毫秒數===" + (lambdaEnd - lambdaStart));
long normalStart = System.currentTimeMillis();
for (int i = 0; i < list.size(); i++) {
// 不用做事情,循環就夠了
}
long normalEnd = System.currentTimeMillis();
System.out.println("普通循環運行毫秒數===" + (normalEnd - normalStart));
輸出爲:
lambda循環運行毫秒數===92
普通循環運行毫秒數===3
你們沒看錯,運行時間差別就是這麼大,並且這並不是只有在循環時使用Lambda表達式纔會導致運行效率低,而是Lambda表達式在運行時就是會需要額外的時間,我們繼續來分析。
二、分析
如果我們要研究Lambda表達式,最正確、最直接的方法就是查看它所對應的字節碼指令。
使用以下命令查看class文件對應的字節碼指令:
javap -v -p Test.class
2.1 不使用Lambda表達式執行循環流程:
81: invokestatic #7 // Method java/lang/System.currentTimeMillis:()J
84: lstore 6
86: iconst_0
87: istore 8
89: iload 8
91: aload_1
92: invokeinterface #18, 1 // InterfaceMethod java/util/List.size:()I
97: if_icmpge 106
100: iinc 8, 1
103: goto 89
106: invokestatic #7 // Method java/lang/System.currentTimeMillis:()J
字節碼指令執行步驟:
- 81:invokestatic: 執行靜態方法,java/lang/System.currentTimeMillis:();
- 84-91: 簡單來說就是初始化數據,int i = 0;
- 92:invokeinterface:執行接口方法,接口爲List,所以真正執行的是就是ArrayList.size方法;
- 97:if_icmpge: 比較,相當於執行i < list.size();
- 100:iinc: i++;
- 103:goto: 進行下一次循環;
- 106:invokestatic: 執行靜態方法;
那麼這個流程大家應該問題不大,是一個很正常的循環邏輯。
2.2 使用Lambda表達式執行循環流程:
我們再來看一下對應的字節碼指令:
33: invokestatic #7 // Method java/lang/System.currentTimeMillis:()J
36: lstore_2
37: aload_1
38: invokedynamic #8, 0 // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;
43: invokeinterface #9, 2 // InterfaceMethod java/util/List.forEach:
// (Ljava/util/function/Consumer;)V
48: invokestatic #7 // Method java/lang/System.currentTimeMillis:()J
字節碼指令執行步驟:
- 33: invokestatic: 執行靜態方法,java/lang/System.currentTimeMillis:();
- 36-37: 初始化數據
- 38: invokedynamic: 這是在幹什麼?
- 43: invokeinterface: 執行java/util/List.forEach()方法
- 48: invokestatic: 執行靜態方法,java/lang/System.currentTimeMillis:();
和上面正常循環的方式的字節碼指令不太一樣,我們認真的看一下這個字節碼指令,這個流程並不像是一個循環的流程,而是一個方法順序執行的流程:
- 先初始化一些數據
- 執行invokedynamic指令(暫時這個指令是做什麼的)
- 然後執行java/util/List.forEach()方法,所以真正的循環邏輯在這裏
所以我們可以發現,使用Lambda表達式循環時,在循環前會做一些其他事情,所以導致執行時間要更長一點。
那麼invokedynamic指令到底做了什麼事情呢?
java/util/List.forEach
方法接收一個參數Consumer<? super T> action
,Consumer是一個接口,所以如果要調用這個方法,就要傳遞該接口類型的對象。
而我們在代碼裏實際上是傳遞的一個Lambda表達式,那麼我們這裏可以假設:需要將Lambda表達式轉換成對象,且該對象的類型需要根據該Lambda表達式所使用的地方在編譯時期進行反推。
這裏在解釋一下反推:一個Lambda表達式是可以被多個方法使用的,而且這個方法所接收的參數類型,也就是函數式接口,是可以不一樣的,只要函數式接口符合該Lambda表達式的定義即可。
本例中,編譯器在編譯時可以反推出,Lambda表達式對應一個Cosumer接口類型的對象。
那麼如果要將Lambda表達式轉換成一個對象,就需要有一個類實現Consumer接口。
所以,現在的問題就是這個類是什麼時候生成的,並且生成在哪裏了?
所以,我們慢慢的應該能夠想到,invokedynamic指令,它是不是就是先將Lambda表達式轉換成某個類,然後生成一個實例以便提供給forEach方法調用呢?
我們回頭再看一下invokedynamic指令:
invokedynamic #8, 0 // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;
Java中調用函數有四大指令:invokevirtual、invokespecial、invokestatic、invokeinterface,在JSR 292 添加了一個新的指令invokedynamic,這個指令表示執行動態語言,也就是Lambda表達式。
該指令註釋中的#0
表示的是BootstrapMethods中的第0個方法:
InnerClasses:
public static final #97= #96 of #100; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
0: #44 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
Method arguments:
#45 (Ljava/lang/Object;)V
#46 invokestatic Test.lambda$main$0:(Ljava/lang/Integer;)V
#47 (Ljava/lang/Integer;)V
所以invokedynamic執行時,實際上就是執行BootstrapMethods中的方法,比如本例中的:java/lang/invoke/LambdaMetafactory.metafactory
。
代碼如下:
public static CallSite metafactory(MethodHandles.Lookup caller,
String invokedName,
MethodType invokedType,
MethodType samMethodType,
MethodHandle implMethod,
MethodType instantiatedMethodType)
throws LambdaConversionException {
AbstractValidatingLambdaMetafactory mf;
mf = new InnerClassLambdaMetafactory(caller, invokedType,
invokedName, samMethodType,
implMethod, instantiatedMethodType,
false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
mf.validateMetafactoryArgs();
return mf.buildCallSite();
}
這個方法中用到了一個特別明顯且易懂的類:InnerClassLambdaMetafactory。
這個類是一個針對Lambda表達式生成內部類的工廠類。當調用buildCallSite方法是會生成一個內部類並且生成該類的一個實例。
那麼現在要生成一個內部類,需要一些什麼條件呢:
- 類名:可按一些規則生成
- 類需要實現的接口:編譯時就已知了,本例中就是Consumer接口
- 實現接口裏面的方法:本例中就是Consumer接口的
void accept(T t)
方法。
那麼內部類該怎麼實現void accept(T t)
方法呢?
我們再來看一下javap -v -p Test.class
的結果中除開我們自己實現的方法外還多了一個方法:
private static void lambda$main$0(java.lang.Integer);
descriptor: (Ljava/lang/Integer;)V
flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
Code:
stack=0, locals=1, args_size=1
0: return
LineNumberTable:
line 17: 0
很明顯,這個靜態的lambda$main$0
方法代表的就是我們寫的Lambda表達式,只是因爲我們例子中Lambda表達式沒寫什麼邏輯,所以這段字節碼指令Code部分也沒有什麼內容。
那麼,我們現在在實現內部類中的void accept(T t)
方法時,只要調用一個這個lambda$main$0
靜態方法即可。
所以到此,一個內部類就可以被正常的實現出來了,內部類有了之後,Lambda表達式就是可以被轉換成這個內部類的對象,就可以進行循環了。