重学 Kotlin —— inline，包治百病的性能良药？-六虎

本文永久更新地址： https://xiaozhuanlan.com/topic/3458207169

重学 Kotlin 现已来到了第三期，前面现已介绍了：

object，史上最 “快” 单例？

typealias ，穿了马甲，我就不知道你了？

今天的主角是 inline ，这不是一个 Kotlin 特有的概念，大多数编程语言都支撑内联。

内联函数的语义很简单： 把函数体复制粘贴到函数调用处。运用起来也毫无困难，用 inli? z u 6ne要害字修饰函数即可。

可是问题的要害并不是怎样运用 inline，而是什么时分运用 inline? 已然 Kotlin 供给了内联，它必定是为了功能优化而存在的，那么，它又真的是包治百病的功能良药吗？

今天，咱们就一起来刨根挖底，寻找一下答案。

inline 的实质

前^ & b o M面现已说过 inline 便是 把函数体复制粘贴到函数调用处，完全是编译器的小把戏。本着严谨科学的情绪，咱们仍是来反编译验证一下。

inline fun test() {
println("I'mO r 7 a inline function")= I 8 , a W
}
f# = C } ? s L @ ^un run() { test(3 C w I Y I s ! q) }

在 run() 函数中调用了内联函数 test()。反编译检查对应的 java 代码：

public static final void test() {
    String var1 = "I'm a inline function";
    Sp v l D K / _ pystem.out.println(var1);
}

public static final void run() {
    String var1 = "I'm a inline function";
    System.o% D } , 4 0 lut.println(var1);
}

能够看到 run()函数中并没有直接调用 test()函数，而是把 test()函数的代码直接放入自己的函数体中。这便是 inline的功效。

那么，问题就来了。这样就能够提高运转功率吗？假如W z & ) 能够，为什么？

咱们先从 JVM 的办法履行机制说起。

JVM 进行办法调用和办法履@ I 3 * w G h J行依赖栈帧，每一个办法从调用开端至履行完| _ . C结的进程，都对应着一个栈帧在虚拟机栈里从入栈到出栈的进程。M U f . 6 s 1 ~ P

线程的栈帧是存储在虚拟机栈中，以上面示例代码的 未内联 版本为例，对应的办法履行进程和对应的栈帧结构如下所示：

未内联的状况下，整个履行进程中会发生两个办法栈帧，每一个办法栈帧都包~ T M { 2含了 部分f R s & ] W变量表、操作数栈、动态连接、办法回来地址和一些额定的附加信息。

运用内联的状况下，只需求一个办法栈帧，降低了办法调用的本钱。

乍一看，的确的提高了运转功率，究竟少用一个栈帧嘛。

可是？

主张不要运用 inline ？

一切看起来都很夸姣，除了 IDE 给我的刺眼提示。

Expected performance impact from inlining is insignificant. Inlining! l O y ^ works bG h 8 : C : uest for functions with parameters of functional types

大致意思是在这儿运用内联对功能的影响微乎其微，或者说没有什么含义。Kotlin 的内* 0 9 u |联最M l 8 y好用在函数参数类型中。

不急着解说，首先来一发魂灵拷问。

Java 支撑内联吗？

你能够说不支撑，由于 Java 并没有供给相似 inline的显示声明内联函数的办法。

可是 JVM 是支撑的。Java 把内联优化交给虚拟q M Y [ k U机来进行，然后防止开发者的滥用。

典型的一种滥用，% o m v ^ z k _ J 内联超长办法，极大的增大字节码长度，反而得不偿失。你能够注意7 c / ) m y Kotlin 规范库中的内联函数，基本都是简略的函数。

关于一般的函数调用，JVM 现已供给了满足的内联支撑。因而，在 Kotlin 中，没有必要为一般函数运用内联，交给 JVM 就行了。

另外，Java 代码是由 javac 编译的U a ~ %，KoD 4 x 5 ! W # s Ktlin 代码是由 kotlinc 编译的，而 JVM 能够对字节码做统一的内联优化。所v H V g 5 .以，能够推断出，不管是 jav) h m 4ac ，仍是 kotlinc，在编译期是没有内联L u ! = ~ : | 优化的。

至于 JVM 具体的内联优化机制，我了解的并不多，这儿就不做过多介绍了。后续P V f | r假如我看到相t O 3 R { w关资料，会到这儿进行补充。7 E ? 6 ] 5 e W

所以，上一节中 IDE 给开发者的提示就很明了了。

JVM 现已供给了内联支撑，所以没有必要在 Kotlin 中内联一般函数。

那么问题又来了。@ + t 已然 JVM 现已支撑内联优化，Kotlin 的内联存在的含义是什么？答案便是 Lambda 。

解救 Lambda

为什么要解救 Lambda，咱们首先得知道Kotlin 的 Lambda 关于 JVM 而言究竟是什么。

Kotlin 规范库中有一个叫 runCatching 的函数，我在这儿完结一个简化版t X 0 F J % J ) h本 runCatch，参数是一个函e B b数类型。

fun runCatch(block: ()P v 5 4 m s  F . -> Unit){
    try {
        block()
    }catch (e:Exception u 0){
        e.printStackTrace()
    }
}

fun run(){
    runCQ C P . U 3 B y Uatch { println("xxx") }
}

反编译生成的 Java 代码如下所示：

public final class InlineKt {
    public static final voidJ 2 v s v runCatch(@NotNull Fun1 E i x _ f i Tction0<Unit> block) {
        Intrinsics.checkw = r C & VParameterIsNotNull(block, (String)"block");
        try {
            block.invoke();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static final void run() {
        InlineKt.runCatch((Function0<Unit&u o Y v K | h ; jgt;)((Function0)run.1.INSTANCE));
    }
}

static final class InlineK N q 0 H J s y ~t.run.19 ~ ; & ; D g + extends Lambda implements Function0<Unit>D A 3 % M 9 : {
    public static final InlineKt.run.1 INSTANCE = new /* invalid duplicate definition of idec t 2 *ntical inner class */;

    pubb N Dlic final void invoke() {
        String string = "xxx";
        bo7 h .olean bl = false;
        SysteP e Y i 6 Am.out.println((Object)string);
    }

    InlineKt.run.1() {
    }
}

Kotlin 自诞生之初，就以 兼容 Java为首要方针。因而，Kotlin 关于 Lambda 表H @ ) & $ f f u ,达式的处理是编译生成匿名类。

经过编译器编译之后， runCatch()办法中的 Lambda 参数被替换为 Function0<Unit>类型，在 run()办法中实践调用 runCatch() 时传入的参数是完结了 Function0<Unit> 接口H D L U p B的 InlineKt.run.1 ，并重写了 invoke()办法。

所以，调用 runCatch()的时分，会创建一个额定的类 InlineKt.run.1。这是 Lambda 没有捕捉变量的场景。假如捕捉了变量，体现会怎样样？

fun runCatch(block: () -> Unit){
    try {
        block()
    }catch (ek h V S | = ? t t:Exception){
        e.prin7 j  l i ( v  $tStackTrace()
    }
}

fun run(){
    var messaO f  V f &ge = "xxx"
    runCatch { println(mes@ ; 5 4  y + |sage) }
}

在 Lambda 内部捕捉了外部变量 messx e a j m a $ ^ }age ，其对应的 javaG # ) 代码如下所示：

public^ i V # z M f, M ` I Vinal class InlineKt {
    public static final void runCatch(@NotNull Function0<Unit> block) {
        Intrinsics.checkParameterIsNotNull(block, (String)"block");
        try {
            block.invoke();
        }
        catch (Exceptionw + S e) {
            e.printStackTrace()V z { F;
        }
    }

    public static final void run() {
        void message;
        Ref.ObjectRef objectRef = new Ref.ObjectRef();
        objectRef.elementJ t y 8 n _ 3 = "xxx";
        // 这儿每次运转都会 new 一g #  ~个对象
        InlineKt.runCatch((Function0<Unit>)((Function0) m . $new Function0<Unit>((Ref.ObjectRef)message){
            final /* synthetic */ Ref.ObjectRef $message;

            public finaB r J g F ] A h Bl void invoke() {
                String string = (String)this.$message.element;
                boop E z 6 w Dlean bl = fa- B klse;
                System.out.println((Objey N M e 4 l q act)string);
            }
            {
                this.$message = o_ Y : z j RbjectRef;
                super(0);
            }
        }));
    }
}

假如 Lambda 捕捉了外部变量，那么每次运转都会 new 一个持有外部变量值的 Function0<Unit> 对象。这比未发生捕捉变量^ 6 x F W的状况更加糟糕。

总而言之，Kotlin 的 Ll 9 F FamW h 7 _ 6bda 为了完全兼容到 Java6，不只增大了编: W q译代码的体积，也带来了额定的运转时开支。为了处理这个问题，Kotlin 供给了 inline 要害字。

KotliJ h n E | o Zn 内联函数的作用是消除 lambda 带来的额M | p x ] = N L定开支r , | 6 s O

给 runCatch() 加持 inC O + o d `line ：

inline fun runCatch(block: () -> Unit){
    try {
        block()
    }catch (e:Exception){
        e.6 - tprintStackTrace()
    }
}

fun run(){
    var message = "xxx"
    runCatch { println(message) }
}

反编译检查 java 代码：

public sto T ,atic final void run() {
      Object message =Y y o 9 % B "xxx";
      boolean var1 =R a `  .  # J v fq f 3 l ] J + c alse;
      try {
         int var2 = false;
         SysteK q H 5m.out.println(me+ g n iss] W  x L 0 Z } Bage);
      } catch (Exception var5) {
         var5.printStackTrace();
      }
}

runCatch()的代码被直接内联到 run(J { 8 J C G q T r)办法中，没有额定生成其他类，消除了 Lambda 带来的额H & u m R w 9 6 –定开支。

Java 是怎样优化 Lambda 的？

已然 Kotlin 的 La7 ( j l & ) Z zmbda 存在功能问题，那周围的 Java 大兄弟必定也逃脱不了。

从 Java8 开端，Java 凭借 invokedH F G h s O y ! uynamic来完结的 Lambda 的优化。

invokedynamic 用于支撑动态语言调用。在初次调用时，它会生成一个调用点，并绑定该调用点对应的办法句柄。后续调用时，直接运转该调用点对应的办法句柄即可。说直白一点，第一次调用 invokeddynamic时，会找到此处应该运转的办法并绑定，后续运转时就直接告知你这儿应该履行哪个办法。

关于 invokedynamic的具体介绍，能够阅览极客时间专栏《深入拆解t @ = 2 tJava虚拟机》的第 8,9 两讲。

JVM 是怎样a f ^ ,完结& u l invokedynamic 的？（上）

JVM 是怎样完结 invokedynamic 的？（下）

不想内联怎样办？

一个高阶函数一旦被符号为内联，它的办法体和一切 Lambda 参数都会被内联。

inline f~ U : nun test(block1i E e 4 & r: () -> Unit, block2: () -> Unit) {
    blockN m [ 7 /1()
    println("xxxp s Z o R m F s $")
    block2()
}

test()函数被符号为了 inline ，所以它的函数体以及两个 Lambda 参数都会被内联。可是m # I G由于我要传入的 block1 代码块巨长(或者q g o其他原因)，我并不想将其内联，这时分就要运用 noinline 。

inline fun test(noinline block1: () -> Unit, block2: () -l j {> Unit) {
    bl0 } 3 + 9 d p D _ock1()
    println("xxx")
    block2()
}

这样，9 k r c O N g e block1就不z H {会被内联了。篇幅原因，这儿就不展现 Java 代码了，相信9 o { 你也能很简单了解 noinline 。

怎样从 Lambda 回来？

首先，一般的 lambda 是不答应直接运用 return的。

fun runCatch(block: () -> Unit) {
    try {
        print("bex - H [ Y  0 6fore lambda! : K P 1")
        block()
        print("after lambda")
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

fun run() {
    // 一般 lambda 不答应 return
    runCatch { return }
}

上面的代码没有办法经过编译，IDE 会提示你 return is not allowed here。而 inline 能够让咱们打破这个约束。

// 符号为 inline
inline fun runCatch(block: () -> Unit) {
    try {
        print("before lambda")
        block()
        print("after lambda")
    } catch (e: Exception) {
        e.pr k kri[ A x H  m R NntStackTrace()
    }
}

fun run() {
    runCatch { return }
}

上N g %面的代码是能够正常编译运转的。和之前的例子仅有的差异便是多了 { D ] Q e _ inline。

已然答应 return ，那么这儿究竟是从 Lambda 中回来，持续运转后边的代码？仍是直接结束外层函数的运转呢？看一下 run() 办法的履行成果。

before lambda

从运转成果来看，是直接结束外层函数的运转。其实不难了解，这个 return 是直接内联到 run()办法内部的，相当于在 run() 办法中直接调用 retud I | mrn。从反编译的 java 代码看，一望而知。

   public static final void run() {
      boolean var0 = false;

      try {
         String var1 = "before lambda";
         System.out.print(var1);
         int var2 = false;
      } catc` x W i . .h (Exception var3) {
         varp l G . { 9 {3.printStackTrace();
      }
   }

编译器直接把 return 之后的代码优化掉了。这样的场景叫做 non-local return (非部分回来)。

可是有些时分我并不想直接退出外层函数，而是只是退出 Lambda 的运转，就能够这样写。

inline fun runCatch(block: () -J 6 / v F W ? o Q> Unit) {
    try {
        print("bW h `efore lambda")
        block()
        print("after lambda")
    } ca_ G J k 8tch (c 7 g = = L 4 w ie: Exception) {
        e.printStan r c # x C F eckTrace()
    }
}

fun run() {
    // 从 lambda 中回来
    runCatch { return@runCatch }
}

return@label，这样就会持续履行 Lambda 之后的代码了。这样的场景叫做 部分回来 。

还有一种场景，我是 API 的设计者，我不想 API 运用者进行非部分回来，改动我的代码流程。同时我又想运用 inline ，这样其实b C 6 J . Q l是抵触的。前面介绍过，内联z 2 v (会让 Lambda 答应非部分回来。

crossinliO j ` O j ` m #ne 便是为了处理这一抵触而生。a M *它能够在保e o Z d 5 } R ,持内联的状况下，制止 lambda 从外层函数直接回来d + d U。

inline fun runCatch(crossinline block: () -> Unitx { ^) {
    try {
        print("before lambda")
        block()
        print("after] r y ; i Y * [ P lambda")
    } catB k [ ? s p 8 Hch (e: Exception)a ^ # ( {
        e.printSt/ Y 5 m G $ $ =ackTrace()
    }
}

fun run() {
    runCatch { return }
}

增加 crossX # E 1 M vinline之后，上面的代码将无法编译。但下面的代码仍然是能够编译运转的。

inline fun runCatch(crossinline block: () -> Unit) {
    try {
        print("before le g z I v ~ G + 9ambda")
        block()
        print("after lambda")
    } catch (e: Excepti0 , f } , Won) {
        e.printSp A E 2 a D HtackTrace()
    }
}

fun run() {
    runCatch { return@runCatch@ s 4 }
}

crossinline能够阻挠非部分回来，但并不能阻挠部分回来，其实也没有必要。

最终

关于内联函数，一口气说了这么多，总结一下。

在 Kotlin 中，内联函数是用来补偿高阶函数中 Lambda 带来的额f S b p定运转开支的。关于一般函数，没有必要运用内联，由于 JVM 现已供给了一定的内联支撑。

对指定的 Lambda 参数运用 noinline ，能够防止该 Lambda 被内联。

一般的 Lambda 不支撑非部分回来，内联之后答应非部分回来。既要内联，又要制止非部分回来，请运用 cro9 v @ssij L _ B xnline 。

除了内联函数之外，Kotlin 1.3 开端支撑 inline class ，但这是一个实验性 API，需求手动敞开编译器支撑。不知道大家对内联类有什么共同的看法，欢迎在谈论区– $ L W Q +交流。

本文运用 mdnice 排版

这儿是秉心说，关注我，不迷路！

重学 Kotlin —— inline，包治百病的性能良药？

目录

inline 的实质

主张不要运用 inline ？

Java 支撑内联吗？

解救 Lambda

Java 是怎样优化 Lambda 的？

不想内联怎样办？

怎样从 Lambda 回来？

最终

作者信息

重学 Kotlin —— inline，包治百病的性能良药？

目录

inline 的实质

主张不要运用 inline ？

Java 支撑内联吗？

解救 Lambda

Java 是怎样优化 Lambda 的？

不想内联怎样办？

怎样从 Lambda 回来？

最终

相关文章

Android Module依赖关系的可视化实现

Flutter 3.7 正式发布

抖音 Android 性能优化系列：启动优化之理论和工具篇

OpenglES之LUT滤镜

作者信息