Kotlin的内联函数探索

在Kotlin中，lambda表达式会被正常的编译成匿名类。这表示每调用一次lambda表达式，一个额外的类就会被创建。并且如果lambda捕捉了某个变量，那么每次调用都会创建一个新的对象。这会带来运行时额外开销，导致使用lambda比使用一个直接执行相同代码的函数效率低。

举个例子：定义一个threadSafeMethod方法，该方法的action参数是一个lambda表达式

没有内联的函数，lambda表达式没有捕捉变量

/**
 * 定义一个线程安全的方法
 */
fun <T> threadSafeMethod(lock: Lock, action: () -> T): T {
    lock.lock()
    try {
        return action()
    } finally {
        lock.unlock()
    }
}

fun main() {

    foo(ReentrantLock())
}

fun foo(l: Lock) {
    println("Before sync")
    threadSafeMethod(l) {
        println("Action")
    }
    println("After sync")
}

看一下反编译Kotlin字节码

public final class Code8_13Kt {
   
   //注释1处
   public static final Object threadSafeMethod(Lock lock,  Function0 action) {
      lock.lock();

      Object var2;
      try {
         var2 = action.invoke();
      } finally {
         lock.unlock();
      }

      return var2;
   }

   public static final void foo(Lock l) {
      Intrinsics.checkParameterIsNotNull(l, "l");
      String var1 = "Before sync";
      System.out.println(var1);
      //注释2处
      threadSafeMethod(l, (Function0)null.INSTANCE);
      var1 = "After sync";
      System.out.println(var1);
   }
}

在注释1处，生成的threadSafeMethod方法的action参数lambda表达式被编译成了一个类Function0。

public interface Function0<out R> : Function<R> {
    /** Invokes the function. */
    public operator fun invoke(): R
}

注释2处，调用threadSafeMethod方法，需要传入一个Function0的实例，因为lambda表达式没有捕捉变量，所以这个实例是可以重复使用的。

没有内联的函数，lambda表达式捕捉变量

fun <T> threadSafeMethod(lock: Lock, action: () -> T): T {
    lock.lock()
    try {
        return action()
    } finally {
        lock.unlock()
    }
}
fun main() {
    foo(ReentrantLock(), 1)
    foo(ReentrantLock(), 2)
    foo(ReentrantLock(), 3)
}

fun foo(l: Lock, number: Int) {

    threadSafeMethod(l) {
        println("Action one $number")
    }
}

查看反编译的Kotlin字节码

public final class Code8_13Kt {
   public static final Object threadSafeMethod(Lock lock, Function0 action) {
      lock.lock();

      Object var2;
      try {
         var2 = action.invoke();
      } finally {
         lock.unlock();
      }

      return var2;
   }

   public static final void main() {
      foo((Lock)(new ReentrantLock()), 1);
      foo((Lock)(new ReentrantLock()), 2);
      foo((Lock)(new ReentrantLock()), 3);
   }

   public static final void foo(Lock l, final int number) {
      Intrinsics.checkParameterIsNotNull(l, "l");
      //注释1处，
      threadSafeMethod(l, (Function0)(new Function0() {
         public Object invoke() {
            this.invoke();
            return Unit.INSTANCE;
         }

         public final void invoke() {
            String var1 = "Action one " + number;
            boolean var2 = false;
            System.out.println(var1);
         }
      }));
   }
}

注释1处：每次调用threadSafeMethod方法的时候，都是new了一个Function0对象。

有没有可能让编译器生成跟Java语句同样高效的代码，但还能把重复的逻辑抽取到库函数中呢？是的，Kotlin编译器能够做到。如果使用inline修饰符标记一个函数，在函数被使用的时候编译器并不会生成函数调用的代码，而是使用函数实现的真实代码替换每一次的函数调用。

当一个函数被声明为inline时，它的函数体是内联的一一换句话说，函数体会被直接替换到函数被调用的地方，而不是被正常调用。我们把threadSafeMethod改为内联函数。

内联的函数

inline fun <T> threadSafeMethod(lock: Lock, action: () -> T): T {
    lock.lock()
    try {
        return action()
    } finally {
        lock.unlock()
    }
}

内联函数，lambda表达式没有捕捉变量

fun main() {

    foo(ReentrantLock())
}

fun foo(l: Lock) {
    println("Before sync")
    threadSafeMethod(l) {
        println("Action")
    }
    println("After sync")
}

看一下反编译Kotlin字节码

public final class Code8_13Kt {
    
   public static final Object threadSafeMethod(Lock lock, Function0 action) {
      lock.lock();

      Object var3;
      try {
         var3 = action.invoke();
      } finally {
         InlineMarker.finallyStart(1);
         lock.unlock();
         InlineMarker.finallyEnd(1);
      }

      return var3;
   }

   public static final void foo(Lock l) {
      Intrinsics.checkParameterIsNotNull(l, "l");
      String var1 = "Before sync";
      System.out.println(var1);

      /****start*******/
      l.lock();

      try {
         String var3 = "Action";
         boolean var4 = false;
         System.out.println(var3);
         Unit var8 = Unit.INSTANCE;
      } finally {
         l.unlock();
      }
      
      /****end*******/

      var1 = "After sync";
      System.out.println(var1);
   }
}

看一下，从注释start到end这段代码，

    /****start*******/
    l.lock();

    try {
        var2 = false;
        String var3 = "Action";
        boolean var4 = false;
        System.out.println(var3);
        Unit var8 = Unit.INSTANCE;
    } finally {
         l.unlock();
    }
      
    /****end*******/

可以看到内联函数threadSafeMethod中的函数体和lambda表达式都被直接插入到了foo方法中。

内联函数，lambda表达式捕捉变量

fun main() {
    foo(ReentrantLock(), 1)
    foo(ReentrantLock(), 2)
    foo(ReentrantLock(), 3)
}

fun foo(l: Lock, number: Int) {

    threadSafeMethod(l) {
        println("Action one $number")
    }
}

看一下反编译Kotlin字节码

public final class Code8_13Kt {
   public static final Object threadSafeMethod(Lock lock, Function0 action) {
      int $i$f$threadSafeMethod = 0;
      Intrinsics.checkParameterIsNotNull(lock, "lock");
      Intrinsics.checkParameterIsNotNull(action, "action");
      lock.lock();

      Object var3;
      try {
         var3 = action.invoke();
      } finally {
         InlineMarker.finallyStart(1);
         lock.unlock();
         InlineMarker.finallyEnd(1);
      }

      return var3;
   }

   public static final void main() {
      foo((Lock)(new ReentrantLock()), 1);
      foo((Lock)(new ReentrantLock()), 2);
      foo((Lock)(new ReentrantLock()), 3);
   }

   public static final void foo(Lock l, int number) {
      Intrinsics.checkParameterIsNotNull(l, "l");
      int $i$f$threadSafeMethod = false;
      l.lock();

      try {
         String var4 = "Action one " + number;
         System.out.println(var4);
      } finally {
         l.unlock();
      }
   }
}

我们看到内联函数threadSafeMethod中的函数体和lambda表达式都被直接插入到了foo方法中。

lambda表达式和函数类型

在foo方法中，我们传入threadSafeMethod方法的action参数是一个lambda表达式

threadSafeMethod(l) {
    println("Action")
}

注意，在调用内联函数时候也可以传递函数类型的变量作为参数：

fun fooTwo(l: Lock, body: () -> Unit) {
    println("Before sync")
    threadSafeMethod(l, body)
    println("After sync")
}

我们定义了fooTwo函数，在内部调用了threadSafeMethod方法，传入threadSafeMethod方法的action参数是一个函数类型。

看一下反编译Kotlin字节码

public static final void fooTwo(@NotNull Lock l, @NotNull Function0 body) {
      String var2 = "Before sync";
      boolean var3 = false;
      System.out.println(var2);
      l.lock();

      try {
         Object var7 = body.invoke();
      } finally {
         l.unlock();
      }

      var2 = "After sync";
      var3 = false;
      System.out.println(var2);
}

我们可以看到threadSafeMethod方法的函数体被内联了，但是action参数没有被内联，因为此时还不知道传入的action参数到底是啥，没法内联。

内联函数多次替换

如果在两个不同的位置使用同个内联函数，但是用的是不同的 lambda表达式，那么内联函数会在每一个被调用的位置被分别内联。内联函数的代码会被拷贝到使用它
的两个不同位置，并把不同的 lambda替换到其中。

fun foo(l: Lock) {

    threadSafeMethod(l) {
        println("Action one")
    }

    threadSafeMethod(l) {
        println("Action two")
    }
}

public static final void foo(@NotNull Lock l) {
      l.lock();

      String var3;
      try {
         //第一次替换
         var3 = "Action one";
         System.out.println(var3);
      } finally {
         l.unlock();
      }

      $i$f$threadSafeMethod = false;
      l.lock();

      try {
         //第二次替换
         var3 = "Action two";
         System.out.println(var3);
      } finally {
         l.unlock();
      }
}

注意：这也意味着，作为内联函数不宜过长，不然，每次都替换，会导致代码量大量增加。

内联函数的限制

鉴于内联的运作方式，不是所有使用lambda的函数都可以被内联。当函数被内联的时候，作为参数的 =lambda 表达式的函数体会被直接替换到最终生成的代码中这将限制lambda参数的使用，如果lambda参数被直接调用，这样的代码能被容易地内联。但如果lambda参数在某个地方被保存起来，以便后面可以继续使用，lambda表达式的代码将不能被内联因为必须要有一个包含这些代码的对象存在。

一般来说，lambda表达式如果被直接调用或者作为参数传递给另外inline函数，它是可以被内联的。否则，编译器会禁止参数被内联并给出错误信息“Illegal usage of inline-parameter ”（非法使用内联参数）。

如果一个函数期望两个或更多 lambda 参数可以选择只内联其中一些参数。这是有道理的，因为一个lambda可能会包含很多代码或者不允许内联的方式使用。接收这样的非内联lambda的参数，可以用 noinline 修饰符来标记它。

inline fun foo(inlined: () -> Unit, noinline notinlined: () -> Unit) { 

}

总结：
对于普通的函数调用，JVM己经提供了强大的内联支持。它会分析代码的执行，并在任何通过内联能够带来好处的时候将函数调用内联。这是在将宇节码转换成机器代码时自动完成的。在字节码中，每一个函数的实现只会出现一次，并不需要跟Kotlin的内联函数一样，每个调用的地方都拷贝一次。再说，如果函数被直接调用，调用栈会更加清晰。

将带有lambda参数的函数内联能带来好处。首先，通过内联避免的运行时开销更明显了。不仅节约了函数调用的开销，而且节约了为lambda创建匿名类，以及创建lambda实例对象的开销。

在使用inline关键字的时候，你还是应该注意代码的长度。如果你要内联的函数很大，将它的字节码拷贝到每一个调用点将会极大地增加字节码的长度。在这种情况下，你应该将那些与lambda参数无关的代码抽取到一个独立的非内联函数中。

部分摘抄自《Kotlin实战》

最后编辑于：2020.03.13 12:41:58

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,214评论 6赞 481
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,307评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 152,543评论 0赞 341
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,221评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,224评论 5赞 371
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,007评论 1赞 284
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,313评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,956评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,441评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,925评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,018评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,685评论 4赞 322
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,234评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,240评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,464评论 1赞 261
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,467评论 2赞 352
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,762评论 2赞 345

Kotlin的内联函数探索

没有内联的函数，lambda表达式没有捕捉变量

没有内联的函数，lambda表达式捕捉变量

内联的函数

内联函数，lambda表达式没有捕捉变量

内联函数，lambda表达式捕捉变量

lambda表达式和函数类型

内联函数多次替换

内联函数的限制

推荐阅读更多精彩内容