內聯函數

定義：用關鍵字inline修飾的函數，叫做內聯函數

作用：它們的函數體在編譯器被嵌入每一個被調用的地方，減少額外生成匿名類和執行函數的開銷

舉個具體的例子：比如下面這個kotlin代碼

fun main() {
foo {
println("I love meitu")
}
}
fun foo(block: () -> Unit) {
println("before block")
block()
println("after block")
}
聲明了一個高階函數foo，可以接受類型為()->Unit的Lamda，可以看下反編譯的java代碼

public final void main() {
String var1 = "I love meitu";
boolean var2 = false;
System.out.println(var1);
this.foo((Function0)null.INSTANCE);
}
public final void foo(@NotNull Function0 block) {
Intrinsics.checkParameterIsNotNull(block, "block");
String var2 = "before block";
boolean var3 = false;
System.out.println(var2);
block.invoke();
var2 = "after block";
var3 = false;
System.out.println(var2);
}
在L5，可以發現額外生成Function0匿名類的開銷

現在，給foo函數增加inline修飾符

inline fun foo(block: () -> Unit) {
println("before block")
block()
println("after block")
}
再來看下對應的java代碼

public final void main() {
int fifoo = 0;
Intrinsics.checkParameterIsNotNull(block, "block");
String var3 = "before block";
boolean var4 = false;
System.out.println(var3);
block.invoke();
var3 = "after block";
var4 = false;
System.out.println(var3);
}
可以發現，foo函數的方法直接被嵌入到調用的地方，通過inline，消除了匿名類的開銷

另外，可以看kotlin官方api的源碼，很多都是定義成了inline函數

public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}

public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
return filterTo(ArrayList<T>(), predicate)
}
到了這里，是不是內心還有一個疑問，上面沒有使用inline的時候，生成的java代碼中this.foo((Function0)null.INSTANCE),是如何跟匿名類扯上關系了

我們先看下Function0

/** A function that takes 0 arguments. /
public interface Function0<out R> : Function<R> {
/* Invokes the function. */
public operator fun invoke(): R
}
其實是一個interface，用于只有0個參數的場景，那這個具體的實現在哪里呢？

這個時候，就不能看生成的java了，需要看更原始的class文件，會發現如下具體實現的地方

final class com/example/myapplication/TestKotlin1 extends kotlin/jvm/internal/Lambda implements kotlin/jvm/functions/Function0
class可以看出來，生成了匿名類TestKotlin1實現了Function0接口，真正執行在這里

// access flags 0x11
public final invoke()V
L0
LINENUMBER 14 L0
LDC "I love meitu"
ASTORE 1
NOP
L1
ICONST_0
ISTORE 2
L2
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 1
INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
L3
NOP
GOTO L4
L4
L5
LINENUMBER 15 L5
RETURN
L6
LOCALVARIABLE this Lcom/example/myapplication/TestKotlin1; L0 L6 0
MAXSTACK = 2
MAXLOCALS = 3

// access flags 0x0
<init>()V
ALOAD 0
ICONST_0
INVOKESPECIAL kotlin/jvm/internal/Lambda.<init> (I)V
RETURN
MAXSTACK = 2
MAXLOCALS = 1
真正的實現，是在這個自動生成的匿名類里面的invoke方法

當然，內聯也不是萬能的，以下的情況需要避免

1、普通函數，不需要使用inline，jvm會自動的判斷是否做內聯的優化，inline都是針對高階函數

2、大量函數體的行數，應該避免，這樣會產生過多的字節碼數量（每次調用的地方，都會重復生產該函數的字節碼）

還有一個特殊的場景：避免被內聯：noinline

有一種可能是函數需要接收多個參數，但我們只想對其中部分Lambda參數內聯，其他的則不內聯，這個又該如何處理呢？

Kotlin在引入inline的同時，也新增了noinline關鍵字，我們可以把它加在不想要內聯的參數開頭，該參數便不會具有內聯的效果。

fun main() {
foo({
println("I love meitu")
}, {
println("I love money")
})
}
inline fun foo(block: () -> Unit, noinline block2: () -> Unit) {
println("before block")
block()
block2()
println("after block")
}
對應的java代碼

public final void main() {
Function0 block2ifoo = false;
String var4 = "before block";
boolean var5 = false;
System.out.println(var4);
int var6 = false;
String var7 = "I love meitu";
boolean var8 = false;
System.out.println(var7);
block2ifoo = 0;
Intrinsics.checkParameterIsNotNull(block, "block");
Intrinsics.checkParameterIsNotNull(block2, "block2");
String var4 = "before block";
boolean var5 = false;
System.out.println(var4);
block.invoke();
block2.invoke();
var4 = "after block";
var5 = false;
System.out.println(var4);
}
可以看出，foo函數中的block2參數在帶上noinline之后，反編譯后的Java代碼中并沒有將其函數體代碼在調用處進行替換。

總結

內聯函數是一種更高效的寫法，很多kotlin官方的方法也都采用
內聯應該盡量用在輕量的方法中，避免生成過多的字節碼