在Kotlin中，使用高阶函数(函数/Lambda作为参数传递)时不良使用会造成性能问题。官方文档表述如下：

kotlin中每一个函数都是一个对象，并且会捕获一个闭包。 即那些在函数体内会访问到的变量。 
内存分配（对于函数对象和类）和虚拟调用会引入运行时间开销。

那在什么情况下函数会捕获闭包，性能隐患是怎么产生的，又是什么时候需要使用内联inline呢？

下面通过几个场景来分析

1.Lambda不访问外部

    val k = 1
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        testInline {
            Logger.d("qintong", "funn33 $it")
        }
    }

    private fun testInline(func : (i : Int) -> Unit) {
        func(k)
    }

用AndroidStudio自带工具查看对应的字节码，为方便查看直接再讲该字节码反编译成java代码，对应的onCreate()部分：

   protected void onCreate(@Nullable Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      this.testInline((Function1)null.INSTANCE);
   }

这里为什么是(Function1)null.INSTANCE？stackoverflow一下：
https://stackoverflow.com/questions/53384931/why-kotlin-decompiler-generates-null-instance

    GETSTATIC com/xxx/xxx/xxx/xxx/x/xxxx/XxxActivity$onCreate$1.INSTANCE : Lcom/xxx/xxx/xxx/xxx/xxx/xxx/XxxActivity$onCreate$1;
    CHECKCAST kotlin/jvm/functions/Function1
    INVOKESPECIAL com/xxx/xxx/xxx/xxx/x/xxxx/XxxActivity.testInline (Lkotlin/jvm/functions/Function1;)V
   L3

可见在编译成字节码显示：

1. GETSTATIC指令取出的静态变量值onCreate$1.INSTANCE，然后推入操作数栈顶
2. CHECKCAST 检查类型
3. INVOKESPECIAL 调用testInline()，弹出栈顶参数onCreate$1.INSTANCE，传入testInline()

由此可见编译成字节码后对应传入testInline()方法的Lambda以Lkotlin/jvm/functions/Function1类型的静态对象onCreate$1.INSTANCE存在。假如onCreate()被反复调用，由于Lambda对应的方法对象为静态对象，应该不存在明显的性能问题。

接下来测试testInline()加上inline后：
用同样方法，kotlin > 字节码 > java代码：

   protected void onCreate(@Nullable Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      int $i$f$testInline = false;
      int it = this.getK();
      int var5 = false;
      Logger.d("qintong", "funn33 " + it);
   }

由此可见testInline()已平铺到onCreate()中，不生成内部对象了。

2.Lambda访问外部类的成员方法

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
       val x = 1
        testInline{
            log(it)
        }
    }

   fun log(it: Int) {
        Logger.d("qintong", "funn22 $it")
    }
     private fun testInline(func : (i : Int) -> Unit) {
        func(k)
    }

同样方法得到对应java代码：

   protected void onCreate(@Nullable Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      int x = true;
      this.testInline((Function1)(new Function1() {
         // $FF: synthetic method
         // $FF: bridge method
         public Object invoke(Object var1) {
            this.invoke(((Number)var1).intValue());
            return Unit.INSTANCE;
         }

         public final void invoke(int it) {
            VersionActivity.this.log(it);
         }
      }));
   }

可见Lambda以匿名内部类的形式传入testInline()方法中。每次testInline()调用都会new一个Function1对象。此时由于Lambda引用了外部对象的方法，导致其编译后难以像第一个例子中优化成一个静态内部对象。
加入onCreate()方法被循环调用，每次调用都会new出一个Function1对象，这会造成一些性能问题：不断创建对象会造成内存抖动，增加gc负担，频繁gc也会造成卡顿。所以此时需要将函数内联：
testInline()加上inline后：

   protected void onCreate(@Nullable Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      int x = true;
      Function1 funxx = (Function1)null.INSTANCE;
      int $i$f$testInline = false;
      int it = this.getK();
      int var7 = false;
      int $i$f$log = false;
      Logger.d("qintong", "funn22 " + it);
   }

和第一个例子一样，内联后testInlint()方法平铺到了onCreate()中，不存在性能问题了。

3.Lambda内访问外部的变量

和上面的例子一样，我们对下面进行测试：

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
       val x = 1
        testInline{
            Logger.d("qintong", "funn11 $it + $x")
        }
    }

    private fun testInline(func : (i : Int) -> Unit) {
        func(k)
    }

对应java代码：

   protected void onCreate(@Nullable Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      final int x = 1;
      this.testInline((Function1)(new Function1() {
         // $FF: synthetic method
         // $FF: bridge method
         public Object invoke(Object var1) {
            this.invoke(((Number)var1).intValue());
            return Unit.INSTANCE;
         }

         public final void invoke(int it) {
            Logger.d("qintong", "funn11 " + it + " + " + x);
         }
      }));
   }

和第二个例子一样，也是会在每次调用时new出对象传入testInline()中，同样有性能问题。
加inline后，结果和前面两个例子一样，就不赘述了。

结论

1. 从实质上，kotlin中使用高阶函数时每一个函数都对应个对象传递给调用方。
2. 使用高阶函数时当函数/Lambda不访问外部的变量/方法（即不捕获外部）时，编译器会将函数对应的对象优化成类的静态成员变量，反复调用时不会有性能问题。此时也不需要使用inline。
3. 当函数/Lambda捕获外部时，比如访问闭包内的参数、访问外部方法时，闭包会一new 内部类对象的方式进行传递，此时如果方法被频繁调用（如在循环中被调用）会造成性能问题：对象被持续创建，造成内存抖动，增加gc负担，频繁gc也可能造成卡顿。
4. 使用inline，方法会被平铺到调用处，不存在上面说的性能问题。
5. inline的使用不当也会有负面作用：由于inline是将函数平铺到调用处，所以要避免内联函数过大。