inline、noinline、crossinline傻傻分不清楚

原创易冬 OhCode

概念

内联函数（inline function）：在计算机科学中，内联函数（有时称作在线函数或编译时期展开函数）是一种编程语言结构，用来建议编译器对一些特殊函数进行内联扩展（有时称作在线扩展）；也就是说建议编译器将指定的函数体插入并取代每一处调用该函数的地方（上下文），从而节省了每次调用函数带来的额外时间开支。但在选择使用内联函数时，必须在程序占用空间和程序执行效率之间进行权衡，因为过多的比较复杂的函数进行内联扩展将带来很大的存储资源开支。另外还需要特别注意的是对递归函数的内联扩展可能引起部分编译器的无穷编译。

简而言之，内联函数就是被调用的地方直接展开，编译器在调用时不用像一般函数那样，參数压栈，返回时參数出栈以及资源释放等，以此来提高程序运行效率。

inline

Kotlin语言中，高阶函数是广受开发者喜爱的特性之一。何为高阶函数呢？高阶函数，就是将函数用作参数或返回值的函数。但是在使用高阶函数过程中会带来一些运行时的效率损失，因为每一个函数都是一个对象。下面举例说明：

class InlineMain {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            greeting {
                println("After")
            }
        }

        private fun greeting(after: () -> Unit) {
            println("Hello")
            after()
        }
    }
}

使用Android Studio字节码查看器“Decompile”到JAVA代码了解大致逻辑：

public final void main(@NotNull String[] args) {
    Intrinsics.checkNotNullParameter(args, "args");
    // 可以看到这里创建了一个对象，然后通过调用invoke方法来运行我们传入的方法
    ((InlineMain.Companion)this).greeting((Function0)null.INSTANCE);
}

private final void greeting(Function0 after) {
    String var2 = "Hello";
    boolean var3 = false;
    System.out.println(var2);
    after.invoke();
}

注意：Android Studio Kotlin字节码查看器反编译的JAVA代码仅供参考，Kotlin生成的JVM字节码不等于JAVA生成的JVM字节码。

从示例中我们可以看出，由于函数类型参数的存在，每调用一次greeting方法都会创建一个临时对象来调用我们传入的方法。如果只是调用一两次是没有什么影响的，但是若是在高频使用场景下，方法可能会被调用100次，1000次，甚至10000次，这样就会有成千上万个临时对象被创建。这在内存分配和虚拟机调用上都会加大运行时间开销。为了解决高阶函数所带来的额外开销，kotlin加入了inline关键字。

还是上面这段代码，greeting添加inline修饰符后，对应字节码反编译的JAVA代码为：

public final void main(@NotNull String[] args) {
    Intrinsics.checkNotNullParameter(args, "args");
    InlineMain.Companion this_$iv = (InlineMain.Companion)this;
    int $i$f$greeting = false;
    String var4 = "Hello";
    boolean var5 = false;
    System.out.println(var4);
    int var6 = false;
    String var7 = "After";
    boolean var8 = false;
    System.out.println(var7);
}

可以看到，不仅greeting函数被内联到了main函数中，函数类型参数也内联进来了。Kotlin折叠了好几层的代码最后被编译器拉平了。通过内联的方式，可以很好的解决高阶函数带来的性能隐患。代码层面的折叠划分，是为了更好的展示业务逻辑，编译器层面的扯平展开，则是为了更快的程序运行。

总结：针对使用频度高，且存在函数类型参数的高阶函数，建议使用inline关键字。

noinline

inline作用于函数，noinline作用于函数类型参数。inline代表整个函数内联，noinline则代表该函数类型参数不参与内联。

假设某内联函数有两个函数类型参数：

class InlineMain {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            greeting({
                println("Before")
            }, {
                println("After")
            })
        }

        private inline fun greeting(before: () -> Unit, after: () -> Unit) {
            before()
            println("Hello")
            after()
        }
    }
}

则字节码反编译后的JAVA代码如下：

public final void main(@NotNull String[] args) {
   Intrinsics.checkNotNullParameter(args, "args");
   InlineMain.Companion this_$iv = (InlineMain.Companion)this;
   int $i$f$greeting = false;
   int var4 = false;
   String var5 = "Before";
   boolean var6 = false;
   System.out.println(var5);
   String var9 = "Hello";
   boolean var10 = false;
   System.out.println(var9);
   var6 = false;
   String var7 = "After";
   boolean var8 = false;
   System.out.println(var7);
}

和预料的一样，两个函数类型参数默认均被内联。但是在某些场景下，我们并不希望所有的函数类型参数都被内联。为了解决此问题，kotlin加入了noinline关键字。但是这里的某些场景，具体指的是哪些场景呢？

未使用内联修饰符时：函数类型参数可作为对象进行使用，我们可以将其赋值给变量，可以将其作为参数传递给另外的函数，也可以将其作为返回值传递出去；
使用内联修饰符后：代码被铺平，临时对象也就不存在了，所以赋值给变量、作为参数传递给另外的函数以及以返回值的方式传递出去均无法实现。

如下，我们在greeting函数中，将after()方法传递给另外的函数使用，Android Studio会提示我们给after加上noinline：

按照Android Studio提示，我们给after添加上noinline以后，字节码反编译后的JAVA代码如下：

public final void main(@NotNull String[] args) {
    Intrinsics.checkNotNullParameter(args, "args");
    InlineMain.Companion this_$iv = (InlineMain.Companion)this;
    // 针对after函数类型参数创建对象
    Function0 after$iv = (Function0)null.INSTANCE;
    int $i$f$greeting = false;
    int var5 = false;
    String var6 = "Before";
    boolean var7 = false;
    System.out.println(var6);
    String var10 = "Hello";
    boolean var11 = false;
    System.out.println(var10);
    access$wrapAfter(this_$iv, after$iv);
    String var8 = "Finish Greeting";
    boolean var9 = false;
    System.out.println(var8);
}

private final void greeting(Function0 before, Function0 after) {
    int $i$f$greeting = 0;
    before.invoke();
    String var4 = "Hello";
    boolean var5 = false;
    System.out.println(var4);
    access$wrapAfter((InlineMain.Companion)this, after);
}

private final void wrapAfter(Function0 after) {
    String var2 = "Before After";
    boolean var3 = false;
    System.out.println(var2);
    after.invoke();
}

可以看到before函数类型参数被内联，而after未被内联。

总结：当使用inline进行函数内联优化时，使用noinline进行局部性的关闭函数的内联优化。更通俗的说，当我们需要在函数内将函数类型参数作为对象操作时，用noinline修饰即可。当然Android Studio也会给予我们友好的语法提醒。

crossinline

noinline解决的是内联函数中的函数类型参数无法当作对象操作的问题，那么crossinline则是解决内联函数中函数类型参数无法被间接调用以及非局部返回的问题。

函数类型参数间接调用

如下，我们在greeting函数中间接调用after参数，Android Studio会提示我们给after加上crossinline：

按照Android Studio提示，我们给after添加上crossinline以后，字节码反编译后的JAVA代码如下：

public final class InlineMain$Companion$main$$inlined$greeting$1 extends Lambda implements Function0 {
   public InlineMain$Companion$main$$inlined$greeting$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 = "After";
      boolean var3 = false;
      System.out.println(var2);
   }
}
……
public final void main(@NotNull String[] args) {
   Intrinsics.checkNotNullParameter(args, "args");
   InlineMain.Companion this_$iv = (InlineMain.Companion)this;
   int $i$f$greeting = false;
   int var4 = false;
   String var5 = "Before";
   boolean var6 = false;
   System.out.println(var5);
   String var8 = "Hello";
   boolean var9 = false;
   System.out.println(var8);
   access$wrapAfter(this_$iv, (Function0)(new InlineMain$Companion$main$$inlined$greeting$1()));
   String var7 = "Finish Greeting";
   $i$f$greeting = false;
   System.out.println(var7);
}

private final void greeting(Function0 before, final Function0 after) {
   int $i$f$greeting = 0;
   before.invoke();
   String var4 = "Hello";
   boolean var5 = false;
   System.out.println(var4);
   access$wrapAfter((InlineMain.Companion)this, (Function0)(new Function0() {
      // $FF: synthetic method
      // $FF: bridge method
      public Object invoke() {
         this.invoke();
         return Unit.INSTANCE;
      }

      public final void invoke() {
         after.invoke();
      }
   }));
}

private final void wrapAfter(Function0 after) {
   String var2 = "Before After";
   boolean var3 = false;
   System.out.println(var2);
   after.invoke();
}

内联函数里函数类型参数不允许间接调用，通过crossinline修饰符允许函数类型参数被间接调用。

非局部返回

Kotlin语言中，Lambda表达式里不允许使用return，除非整个Lambda表达式是内联函数的参数。

如下，我们在after函数类型参数末尾添加return语句：

class InlineMain {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            greeting({
                println("Before")
            }, {
                println("After")
                return
            })
            println("Finish Greeting")
        }

        private inline fun greeting(before: () -> Unit, after: () -> Unit) {
            before()
            println("Hello")
            after()
        }
    }
}

由于函数内联优化，两个函数类型参数均被内联，代码铺平后，return直接结束了main方法，导致println("Finish Greeting")未执行，同理，如果我们在before函数类型参数表达式末尾添加return，程序会结束得更早。简言之，针对Lambda表达式：

普通Lambda表达式，不允许使用return语句，Android Studio会直接编译报错。
作为内联函数参数的Lambda表达式，允许使用return语句，但是结束的不是直接外层函数，而是外层再外层的函数。当然，Lambda表达式也可以使用return@label的方式来显示指定返回的位置。

但是，如上文中示例，若我们在添加了crossinline修饰符的函数类型参数对应的Lambda表达式中添加return语句，Android Studio会直接提示return is not allowed here。作为内联函数参数的Lambda表达式被间接调用时，如果Lambda表达式中可以使用return，会导致return将无法按照预期的行为进行工作，会让整个代码逻辑很混乱。所以，要么使用return@label的方式明确告诉它return到何处，要么就禁止使用return。