用Kotlin开发时，如何优化一下Lambda的开销

前言

在Kotlin中声明一个Lambda表达式，在编译字节码中会产生一个匿名类。此匿名类中有一个 invoke方法，为Lambda的调用方法，每次调用会创建一个新匿名类对象。可想而知，Lambda语法虽简洁，但额外增加的开销也不少。还有，若Lambda捕捉某个变量，每次调用时都会创建一个新对象，会导致效率较低。

在Kotlin中采取优化Lambda额外开销的方式就是：内联函数。

回顾Java中采取的优化方式：invokedynamic

invokedynamic技术是Java7后提出，在运行期才产生相应翻译代码。
invokedynamic被首次调用时，会触发产生一个匿名类来替换中间码invokedynamic，后续调用会直接采用该匿名类代码。这种做的好处主要有：

• 
  
• 具体的转换实现是在运行时产生，在字节码中只有一个固定的invokedynamic，所以需要静态生成的类的个数及字节码大小都显著减少。
  
• 与编译时写死在字节码中的策略不同，利用invokedynamic可把实际的翻译策略隐藏在JDK库的实现， 极大提高了灵活性，在确保向后兼容性的同时，后期可以继续对编译策略不断优化升级
  
• JVM天然支持针对该方式的Lambda表达式的翻译和优化，开发者在书写Lambda表达式时，可以完全不用关心这个问题，极大地提升了开发体验。
  

Kotlin中采取的优化方式：内联函数

Kotlin拥抱内联函数，在C++、C#等语言中也支持这种特性。可以用 inline 关键字来修饰函数，这些函数就称为内联函数。它的函数体在编译期被嵌入到每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。

内联函数的工作原理并不复杂，就是Kotlin编译器会将内联函数中的代码在编译的时候自动替换到调用它的地方，这样就不存在运行时的开销。

若想在用Kotlin开发时获得尽可能良好的性能支持，以及控制匿名类的生成数量，就来学习下内联函数：

如以下示例:

fun main() {
    foo {
        println("dive into Kotlin...")
    }
}

fun foo(block: () -> Unit) {
    println("before block")
    block()
    println("end block")
}

以上声明一个高阶函数foo，接受一个Lambda 参数为 () -> Unit，最后在main函数中调用它。下面是通过字节码反编译的Java代码:

public static final void main(@NotNull String[] args) {
    Intrinsics.checkParameterIsNotNull(args, "args");
    foo((Function0)null.INSTANCE);	        
}

public static final void foo(@NotNull Function0 block) {
    Intrinsics.checkParameterIsNotNull(block, "block");
    String var1 = "before block";
    System.out.println(var1);
    block.invoke();
    var1 = "end block";
    System.out.println(var1);
}

调用foo会产生一个Function()类型的block类，然后通过 invovke() 来执行，这样会增加额外生成类和调用开销。下面给foo函数加上inline修饰符:

inline fun foo(block: () -> Unit) {
    println("before block")
    block()
    println("end block")
}

看看相应Java代码:

public static final void main(@NotNull String[] args) {
    Intrinsics.checkParameterIsNotNull(args, "args");
    String va1 = "before block";
    System.out.println(var1);
    // block函数体在这里开始粘贴
    String var2 = "dive into Kotlin...";
    System.out.println(var2);
    // block函数体在这里结束粘贴
    var1 = "end block";
    System.out.println(var1);
}

public static final void foo(@NotNull Function0 block) {
    Intrinsics.checkParameterIsNotNull(block, "block");
    String var2 = "before block";
    System.out.println(var2);
    block.invoke();
    var2 = "end block";
    System.out.println(var2);
}

如上面所说，foo 函数体代码及被调用的Lambda代码都粘贴到了相应调用的位置。试想下，若是一个公共方法，或被嵌套在一个循环调用中，该方法势必会被调用很多次。通过inline函数，可以消除这种额外调用，从而节省开销。

内联函数一个典型应用场景就是Kotlin集合类。Kotlin 中集合函数式API，如map、filter都是被定义成内联函数：

inline fun <T, R> Array<out T>.map {
    transform: (T) -> R
}: List<R>

inline fun <T> Array<out T>.filter {
    predicate: (T) -> Boolean
}: List<T>

很容易理解，因这些方法都接收Lambda表达式参数，需要对集合元素进行遍历操作，因此把相应的实现进行内联无疑是适合的。

但内联函数不是万能的，以下情况应避免使用内联函数:

• 
  
• JVM对普通函数已经能够根据实际情况智能判断是否进行内联优化，因此并不需要对其使用Kotlin的inline语法，否则只会让字节码变得更加复杂
  
• 尽量避免对具有大量函数体的函数进行内联，会导致过多的字节码数量
  
• 一个函数被定义为内联函数，就不能获取闭包类的私有成员，除非把它声明为internal