说说kotlin的内联函数-inline

2021-09-29 15:28:05 浏览数 (1)

内联函数

定义：用关键字inline修饰的函数，叫做内联函数

作用：它们的函数体在编译器被嵌入每一个被调用的地方，减少额外生成匿名类和执行函数的开销

举个具体的例子：比如下面这个kotlin代码

代码语言：javascript复制
fun main() {
    foo {
        println("I love meitu")
    }
}
fun foo(block: () -> Unit) {
    println("before block")
    block()
    println("after block")
}

声明了一个高阶函数foo，可以接受类型为()->Unit的Lamda，可以看下反编译的java代码

代码语言：javascript复制
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修饰符

代码语言：javascript复制
inline fun foo(block: () -> Unit) {
        println("before block")
        block()
        println("after block")
    }

再来看下对应的java代码

代码语言：javascript复制
public final void main() {
   int $i$f$foo = false;
   String var3 = "before block";
   boolean var4 = false;
   System.out.println(var3);
   int var5 = false;
   String var6 = "I love meitu";
   boolean var7 = false;
   System.out.println(var6);
   var3 = "after block";
   var4 = false;
   System.out.println(var3);
}
public final void foo(@NotNull Function0 block) {
   int $i$f$foo = 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函数

代码语言：javascript复制
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

代码语言：javascript复制
/** 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文件，会发现如下具体实现的地方

代码语言：javascript复制
final class com/example/myapplication/TestKotlin$main$1 extends kotlin/jvm/internal/Lambda implements kotlin/jvm/functions/Function0

class可以看出来，生成了匿名类TestKotlinmain1实现了Function0接口，真正执行在这里

代码语言：javascript复制
// 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/TestKotlin$main$1; 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关键字，我们可以把它加在不想要内联的参数开头，该参数便不会具有内联的效果。

代码语言：javascript复制
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代码

代码语言：javascript复制
public final void main() {
   Function0 block2$iv = (Function0)null.INSTANCE;
   int $i$f$foo = 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);
   block2$iv.invoke();
   var4 = "after block";
   var5 = false;
   System.out.println(var4);
}
public final void foo(@NotNull Function0 block, @NotNull Function0 block2) {
   int $i$f$foo = 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官方的方法也都采用
  • 内联应该尽量用在轻量的方法中，避免生成过多的字节码

行数：206

字数：1151

主题：默认主题

c++ java kotlin

0 人点赞