内联函数

定义：用关键字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官方的方法也都采用
内联应该尽量用在轻量的方法中，避免生成过多的字节码