首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >说说kotlin的内联函数-inline

说说kotlin的内联函数-inline

作者头像
韦东锏
发布2021-09-29 15:28:05
8210
发布2021-09-29 15:28:05
举报
文章被收录于专栏:Android码农Android码农

内联函数

定义:用关键字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 $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函数

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/TestKotlin$main$1 extends kotlin/jvm/internal/Lambda implements kotlin/jvm/functions/Function0

class可以看出来,生成了匿名类TestKotlinmain1实现了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/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关键字,我们可以把它加在不想要内联的参数开头,该参数便不会具有内联的效果。

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 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

主题:默认主题

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2020-08-28,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Android码农 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档