Kotlin inline、noinline、crossinline 深入解析

主要内容:

  • inline
    • 高价函数的原理分析
    • Non-local returns
  • noinline
  • crossinline

inline

如果有C语言基础的,inline 修饰一个函数表示该函数是一个内联函数。编译时,编译器会将内联函数的函数体拷贝到调用的地方。我们先看下在一个普通的 kotlin 函数上使用 inline 关键字:

inline fun inlineFun() {
    println("from inlineFun")
}

会发现 IDE 会给出警告:

在这里插入图片描述
建议我们在高阶函数上使用 inline 关键字。

好,那我们来看下高阶函数。

高价函数的原理分析

下面是一个简单的高阶函数,函数参数是一个 function type 类型:

private fun proxy(action: () -> Unit) {
    println("start logging")
    action()
    println("end logging")
}

编译后对应的 Java 代码为:

private final void proxy(Function0 action) {
  String var2 = "start logging";
  System.out.println(var2);
  action();
  var2 = "end logging";
  System.out.println(var2);
}

会将 function type 编译成 Function0 类型,因为 action: () -> Unit括号内是无参的,所以是 Function0,如果是一个参数对应 Function1,以此类推。然后,我们调用上面的高阶函数 proxy:

fun invokeProxy() {
    proxy {
        println("eating")
    }
}

查看对应的字节码:

  public final invokeProxy()V
   L0
    LINENUMBER 34 L0
    ALOAD 0
    GETSTATIC inline/InlineTest$invokeProxy$1.INSTANCE : Linline/InlineTest$invokeProxy$1;
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKESPECIAL inline/InlineTest.proxy (Lkotlin/jvm/functions/Function0;)V
   L1
    LINENUMBER 38 L1
    RETURN
   L2
    LOCALVARIABLE this Linline/InlineTest; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1

可以看出,编译后会生成一个内部类:inline/InlineTest$invokeProxy$1,然后我们看下这个内部类长什么样:

final class inline/InlineTest$invokeProxy$1 extends kotlin/jvm/internal/Lambda implements kotlin/jvm/functions/Function0 {
  // access flags 0x1041
  public synthetic bridge invoke()Ljava/lang/Object;
   L0
    LINENUMBER 15 L0
    ALOAD 0
    INVOKEVIRTUAL inline/InlineTest$invokeProxy$1.invoke ()V
    GETSTATIC kotlin/Unit.INSTANCE : Lkotlin/Unit;
    ARETURN
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x11
  public final invoke()V
   L0
    LINENUMBER 36 L0
    LDC "eating"
    ASTORE 1
   L1
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
   L2
   L3
    LINENUMBER 37 L3
    RETURN
   L4
    LOCALVARIABLE this Linline/InlineTest$invokeProxy$1; L0 L4 0
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x0
  <init>()V
    ALOAD 0
    ICONST_0
    INVOKESPECIAL kotlin/jvm/internal/Lambda.<init> (I)V
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x19
  public final static Linline/InlineTest$invokeProxy$1; INSTANCE

  // access flags 0x8
  static <clinit>()V
    NEW inline/InlineTest$invokeProxy$1
    DUP
    INVOKESPECIAL inline/InlineTest$invokeProxy$1.<init> ()V
    PUTSTATIC inline/InlineTest$invokeProxy$1.INSTANCE : Linline/InlineTest$invokeProxy$1;
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 0

  @Lkotlin/Metadata;(mv={1, 8, 0}, k=3, d1={"u0000u0008nu0000nu0002u0010u0002nu0000u0010u0000u001au00020u0001Hnu00a2u0006u0002u0008u0002"}, d2={"<anonymous>", "", "invoke"})
  OUTERCLASS inline/InlineTest invokeProxy ()V
  // access flags 0x18
  final static INNERCLASS inline/InlineTest$invokeProxy$1 null null
  // compiled from: InlineTest.kt
}

上面的字节码,类似下面的伪代码:

final class InlineTest$invokeProxy$1 extends kotlin/jvm/internal/Lambda implements kotlin/jvm/functions/Function0 {
 public final static InlineTest$invokeProxy$1 INSTANCE;
    
    static {
       INSTANCE = new InlineTest$invokeProxy$1()
    }

    public void invoke(){
     System.out.println("eating")
    }
}

可以看出,调用高阶函数 proxy,会生成内部类(该内部类是一个单例)将lambda体里的代码,拷贝到 invoke 函数里面。

小结:简单来说,就是有多少个调用点(call site 调用高阶函数的地方)就会产生多少个内部类。

我们继续往下看,如果在 lambda 表达式体里访问外部的变量呢:

class InlineTest {
    var age = 18
    private fun proxy(action: () -> Unit) {
        println("start logging")
        action()
        println("end logging")
    }
 fun invokeProxy() {
        proxy {
            age = 11 // 访问外部的成员变量
            println("eating")
        }
    }
}

invokeProxy对应的字节码如下:

  public final invokeProxy()V
   L0
    LINENUMBER 34 L0
    ALOAD 0
    NEW inline/InlineTest$invokeProxy$1
    DUP
    ALOAD 0
    INVOKESPECIAL inline/InlineTest$invokeProxy$1.<init> (Linline/InlineTest;)V
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKESPECIAL inline/InlineTest.proxy (Lkotlin/jvm/functions/Function0;)V
   L1
    LINENUMBER 38 L1
    RETURN
   L2
    LOCALVARIABLE this Linline/InlineTest; L0 L2 0
    MAXSTACK = 4
    MAXLOCALS = 1

对应的 Java 伪代码如下:

public final void invokeProxy(){
 InlineTest$invokeProxy$1 function0 = new InlineTest$invokeProxy$1()
    proxy(function0)
}

该内部类 InlineTest$invokeProxy$1 变成如下:

final class InlineTest$invokeProxy$1 extends kotlin/jvm/internal/Lambda implements kotlin/jvm/functions/Function0 {
    public void invoke(){
        InlineTest$invokeProxy$1.this.setAge(11)
     System.out.println("eating")
    }
}

可以看出每调用一次高阶函数 proxy 会都会创建一个内部类对象。

小结:

  1. 每个调用高阶函数地方(调用点),编译时,编译器都会生成一个内部类
  2. 调用高阶函数时,如果传入的 lambda 表达式体没有使用外部变量,那么只会用到内部类常量对象;如果 lambda 表达式体使用了外部变量,那么每次调用该高阶函数都会创建一个内部类对象。
    如果在一个频繁触发的地方调用高阶函数,如自定义 draw 方法里,刚好 lambda 体又实用到了外部成员变量,这样就会隐性地在 draw 方法里频繁创建对象。

这样时候 inline 关键字就派上用场了。

将上面的高阶函数 proxy 使用 inline 修饰:

private inline fun proxy(action: () -> Unit) {
    println("start logging")
    action()
    println("end logging")
}

调用该高阶函数:

fun invokeProxyInline() {
    proxy {
        println("eating")
    }
}

字节码对应的 Java 代码如下:

public final void invokeProxyInline() {
    int $i$f$proxyInline = false;
    String var3 = "start logging";
    System.out.println(var3);
    int var4 = false;
    String var5 = "eating";
    System.out.println(var5);
    var3 = "end logging";
    System.out.println(var3);
}

可以看出调用 proxy 函数的地方不会创建内部类,而是将高阶函数的函数体拷贝到调用点。

Non-local returns

什么是 Non-local returns?我们先来看下什么是 return,下面是 kotlin 对 return 的定义:

by default returns from the nearest enclosing function or anonymous function.

意思就是:从离 return 最近的封闭函数或匿名函数中返回。举个例子:

fun test(age:Int) {
    if (age < 0) {
        return
    }
 println(age)
}

其中 test就是 enclosing function. 也就是说 return 的作用就是从一个函数中返回(离它最近的函数)。

搞清楚 return 关键字之后,我们来看下在 lambda 中使用 reutrn:

// 定义一个普通的高阶函数
private fun normalFunction(action: () -> Unit){
    println("start......")
    action()
    println("end......")
}

main(){
    // 调用高阶函数
    normalFunction {
        return // 使用 return, 编译器报错
    }
}

发现编译器报错了,为啥不能在 lambda 中使用 return 呢?

首先,上面代码中里离 return关键字最近的 enclosing function是 main函数,有人可能会问,离 return最近的不是 normalFunction么?normalFunction只是一个函数调用,它不是一个封闭的函数,封闭的是 lambda 表达式。

其次,return也无法控制 normalFunction函数的 return的。因为 return所处的代码块只是 normalFunction的 lambda 参数而已,return控制的是 lambda。正如 Kotlin 官网所说的:

A bare return is forbidden inside a lambda because a lambda cannot make the enclosing function return.

因为在 lambda 中使用return,无法实现 return 的定义,所以无法在 lambda 中使用 return,如果是内联函数,则可以在 lambda 中使用 return:

private inline fun normalFunction(action: () -> Unit){
    println("start......")
    action()
    println("end......")
}

main(){
    // 调用高阶函数
    normalFunction {
        return
    }
}

上面的代码是合法的(因为内联 normalFunction,编译时会将代码体拷贝到main函数中).

Kotlin 中把这种 return 称之为 Non-local returns(located in a lambda, but exiting the enclosing function).
Non-local returns 名字很好理解:return 的 local 是 lambda,而此处的 return 返回的是 lambda 外面的 main 函数(non-local),所以称之为 non-local returns.

noinline

noinline 顾名思义就是不内联。那是什么时候使用 noinline 呢?我们在上面 proxy 函数基础上做一个小修改:

private inline fun proxy(action: () -> Unit, action2: () -> Unit) {
    println("start logging")
    action()
    println("end logging")
    // action2 作为参数传递给另一个高阶函数
    cleanResource(action2)
}

private fun cleanResource(execution: () -> Unit) {
    execution()
    println("cleaning resource1")
    println("cleaning resource2")
}

为了 proxy 新增了另一个参数 action2,然后将 action2 传递给高阶函数 cleanResource. 但是 IDEA 会提示如下错误:
在这里插入图片描述
提示我们使用 noinline 修饰 action2 参数:

private inline fun proxy(action: () -> Unit, noinline action2: () -> Unit) {
    println("start logging")
    action()
    println("end logging")
    // action2 作为参数传递给另一个高阶函数
    cleanResource(action2)
}

为什么不加 noinline 就会报错呢?

其实很好理解,因为 proxy 是一个 inline 函数,那么调用 proxy 的地方,编译器都会将函数体拷贝过去,包括传入的 lambda 参数(如上面的 action,action2),例如:

fun invokeProxy() {
    proxy({
        println("eating...")
    }, {
        println("eating...2")
    })
}

action对应的代码块是:println("eating..."),action2 对应的代码块是:println("eating...2")

因为action2传递给了 cleanResource,要想将代码块当做参数传递给函数,那么代码块用什么来表示,目前只能使用Class类。然而 proxy又是 inline 的,所以需要对 action2 参数单独处理,将其不要 inline。所以需要使用 oninline关键字来修饰 action2参数。

小结:如果需要将 inline 高阶函数的 lambda 参数传递给另一个高阶函数或作为函数的返回值,均需要使用 noinline 关键字修饰该参数。

crossinline

介绍完了 inline 和 noinline,我们来看下 crossinline。将上面的 proxy 函数,稍作修改:

private fun wrap(action: () -> Unit) {
    action.invoke()
}

private inline fun proxy(action: () -> Unit) {
    println("start logging")
    wrap {
        action()
    }
    println("end logging")
}

编译器会报错,给出如下提示:

在这里插入图片描述
编译器报错原因:action 可能包含 Non-local returns,Kotlin 中不允许在非内联的 lambda 中使用 return(原因已经在 Non-local returns 章节已介绍了),也就是说 action 代码块中可能存在 return 关键字,需要使用 crossinline 来修饰 action 参数:

private inline fun proxy(crossinline action: () -> Unit) {
    println("start logging")
    wrap {
        action()
    }
    println("end logging")
}

// 调用 proxy
private fun invokeProxy() {
    proxy{
        println("invoke acrossinline")
    }
}

我们看下 invokeProxy字节码:

// 内部类
public final class InlineTest$invokeProxy$$inlined$proxy$1 extends Lambda implements Function0 {
   public InlineTest$invokeProxy$$inlined$proxy$1() {
      super(0);
   }

   // $FF: synthetic method
   // $FF: bridge method
   public Object invoke() {
      this.invoke();
      return Unit.INSTANCE;
   }

   public final void invoke() {
      int var1 = false;
      String var2 = "invoke acrossinline";
      System.out.println(var2);
   }
}

private final void invokeProxy() {
    int $i$f$proxy = false;
    String var3 = "start logging";
    System.out.println(var3);
    // 每次都 new 一个内部类对象
    access$wrap(this, (Function0)(new InlineTest$invokeProxy$$inlined$proxy$1()));
    var3 = "end logging";
    System.out.println(var3);
}

可以看出会生成一个内部类

  • InlineTest$invokeProxy$$inlined$proxy$1

并且每次调用都会创建一个内部类对象。crossinline 阻止了 action 参数内联。

可以到看 crossinline 的核心作用是阻止内联,那我们将 crossinline 换成 noinline 是不是也可以呢?

private inline fun proxy(noinline action: () -> Unit) {
    println("start logging")
    wrap {
        action()
    }
    println("end logging")
}

编译器不会报错,代码运行也是OK,貌似可以使用 noinline 代替 crossinline,既然可以用 noinline,为啥还搞个新的 crossinline 关键字?上面的代码虽然可以使用 noinline 代替 crossinline,但是底层还差别的。我们看下使用 noinline 对应的字节码:

  public final invokeProxy()V
   L0
    LINENUMBER 135 L0
    ALOAD 0
    ASTORE 1
    GETSTATIC inline/InlineTest$invokeProxy$1.INSTANCE : Linline/InlineTest$invokeProxy$1;
    CHECKCAST kotlin/jvm/functions/Function0
    // 省略其他代码
   L5
    LINENUMBER 184 L5
    ALOAD 1
    NEW inline/InlineTest$proxy$1
    DUP
    ALOAD 2
    INVOKESPECIAL inline/InlineTest$proxy$1.<init> (Lkotlin/jvm/functions/Function0;)V
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKESTATIC inline/InlineTest.access$wrap (Linline/InlineTest;Lkotlin/jvm/functions/Function0;)V
    // 省略其他...

可见,使用 noinline 的话,会创建两个内部类:

  • inline/InlineTest$invokeProxy$1
  • inline/InlineTest$proxy$1

至此,inline、noinline 和 crossinline 就介绍完毕了。