Kotlin inline内联函数

今天介绍下 Kotlin 中 非常重要的 内联函数，小伙伴系紧鞋带准备发车

普通函数调用

下面测试整数相加的情况

fun calculate() {
    println(add(a = 1, b = 3))
}

fun add(a: Int, b: Int) = a + b

反编译查看下 java 代码（Android Studio或idea下可以使用 kotlin插件直接查看，路径是 Tools → Kotlin → Show Kotlin Bytecode → DECOMPILE）

public final void calculate() {
  int var1 = this.add(1, 3);
  System.out.println
}

final int add(int a, int b) {
  return a + b;
}

可以看到这是一个正常的函数调用，在calculate函数内部调用了add

inline修饰的普通函数

我们再来看下将add添加了inline的效果

fun calculate() {
    println(add(a = 1, b = 3))
}

inline fun add(a: Int, b: Int) = a + b

反编译查看下 java 代码

public final void calculate() {
  byte a$iv = 1;
  int b$iv = 3;
  int $i$f$add = false;
  int var1 = a$iv + b$iv;
  System.out.println(var1);
}

final int add(int a, int b) {
  int $i$f$add = 0;
  return a + b;
}

可以看到calculate调用了inline函数add，编译时期将add函数方法体拷贝到了调用的地方，意味着方法的调用栈少了一层
add函数虽然可以是可以添加inline，不过编译器却给出了警告

common_inline_warn.png

大概意思就是inline函数在此并不会提高性能，inline更适合在函数参数为函数类型的函数中使用（高阶函数）

普通高阶函数

我们来看下不加inline的lambda参数的情况

fun calculate() {
    add(a = 1, b = 3) {
        println("a + b = $it")
    }
}

fun add(a: Int, b: Int, result: (Int) -> Unit): Int {
    val sum = a + b
    result.invoke(sum)
    return sum
}

反编译查看下 java 代码

public final void calculate() {
  this.add(1, 3, (Function1)null.INSTANCE);
}

public final int add(int a, int b, Function1 result) {
  int sum = a + b;
  result.invoke(sum);
  return sum;
}

是不是发现很奇怪，我们的lambda竟然转换成了(Function1)null.INSTANCE，这是个啥东西？
其实(Function1)null.INSTANCE，是由于反编译器工具在找不到等效的 Java 类时的显示的结果。
这个时候我们就需要使用到我们的反编译工具 jadx了，这里附带 jadx 的地址，有需要学习的小伙伴可自行查阅

jadx 下的代码是这样的

public final void calculate() {
    add(1, 3, calculate$1.INSTANCE);
}

public final int add(int a, int b, Function1 result) {
    Intrinsics.checkNotNullParameter(result, "result");
    int sum = a + b;
    result.mo2833invoke(Integer.valueOf(sum));
    return sum;
}

final class calculate$1 extends Lambda implements Function1 {
   public static final calculate$1 INSTANCE = new calculate$1();

    calculate$1() {
        super(1);
    }

    @Override // kotlin.jvm.functions.Function1
    /* renamed from: invoke */
    public /* bridge */ /* synthetic */ Unit mo2922invoke(Integer num) {
        invoke(num.intValue());
        return Unit.INSTANCE;
    }

    public final void invoke(int it) {
        System.out.println((Object) ("a + b = " + it));
    }
}

可以看到 lambda 表达式转换成了一个 Function1 对象，它是 Kotlin 函数的一部分，那为什么是 Function1呢，实际上是因为 lambda 中传递了一个参数，如果没传递参数则是 Function0，以此类推。这个 Function1 对象的创建无疑是会消耗内存的，假如我们的代码中存在很多的高阶函数（参数类型是函数或者返回值类型是函数，在代码编译之后那么是不是会创建很多的 Function对象呢？这个内存的消耗是不可估计的，所以 Kotlin 官方为了优化这个点，出现了 inline 内联函数

inline修饰的高阶函数

我们还是继续使用上面的例子来看下 inline 内联函数是如何提高性能的

fun calculate() {
    add(a = 1, b = 3) {
        println("a + b = $it")
    }
}

inline fun add(a: Int, b: Int, result: (Int) -> Unit): Int {
    val sum = a + b
    result.invoke(sum)
    return sum
}

继续反编译看下 java 代码

public final void calculate() {
  byte a$iv = 1;
  int b$iv = 3;
  int $i$f$add = false;
  int sum$iv = a$iv + b$iv;
  int var7 = false;
  String var8 = "a + b = " + sum$iv;
  System.out.println(var8);
}

public final int add(int a, int b, @NotNull Function1 result) {
  int $i$f$add = 0;
  Intrinsics.checkNotNullParameter(result, "result");
  int sum = a + b;
  result.invoke(sum);
  return sum;
}

可以看到相比于不加 inline ，方法的调用栈少了一层，并且不会生成额外的对象，这对内存还说是一个很棒的优化。一般情况下我们在高频调用的高阶函数下使用inline ，减少内存的消耗。

noinline

noinline 刚好跟 inline 相反， 它是让 高阶函数中函数类型的参数 不参与内联，先来看下为什么会有 noinline
函数类型的参数不止可以当做函数去调用，还可以当做对象去使用，例如我们把它当做函数返回值
我们还是以上面为示例修改下代码

fun calculate() {
    add(a = 1, b = 3,
        addPrev = {
            println("addPrev!")
        }, result = {
            println("a + b = $it")
        }, addPost = {
            println("addPost!")
        }
    )
}

inline fun add(a: Int, b: Int, addPrev: () -> Unit, result: (Int) -> Unit, addPost: () -> Unit): () -> Unit {
    addPrev.invoke()
    val sum = a + b
    result.invoke(sum)
    return addPost
}

上面的代码编译是不会通过的，并且编译器给出了错误提示

noinline_warn.png

我们知道在 inline 内联函数中函数类型的参数是不会创建函数对象的，它仅仅是作为一个函数体存在而不是一个函数对象，所以无法当成一个对象进行返回
如果我们还是需要将函数类型的参数作为对象去使用，编译器也给出了解决方案，给函数类型的参数加上 noinline 即可

fun calculate() {
    add(a = 1, b = 3,
        addPrev = {
            println("addPrev!")
        }, result = {
            println("a + b = $it")
        }, addPost = {
            println("addPost!")
        }
    )
}

inline fun add(
    a: Int,
    b: Int,
    addPrev: () -> Unit,
    result: (Int) -> Unit,
    noinline addPost: () -> Unit
): () -> Unit {
    addPrev.invoke()
    val sum = a + b
    result.invoke(sum)
    return addPost
}

crossinline

crossinline 是局部加强内联的意思
我们来看下下面这个场景，在 lambda 内部直接return

fun main() {
    linpopopo {
        println("linpopopo function")
        return
    }
    println("main function")
}

inline fun linpopopo(action: () -> Unit) {
    action.invoke()
}

这个return会结束那个函数？linpopopo？main？

按常理来说，这个return会结束 linpopopo函数的执行，后面的 println("main function") 会被执行，不过这里是 linpopopo 内联函数，它在编译的时候会将函数体移到调用的地方，我们来看下编译之后的代码就清楚了

public final void main() {
  int $i$f$linpopopo = false;
  int var3 = false;
  String var4 = "linpopopo function";
  System.out.println(var4);
}

public final void linpopopo(@NotNull Function0 action) {
  int $i$f$linpopopo = 0;
  Intrinsics.checkNotNullParameter(action, "action");
  action.invoke();
}

看到了吧，这里 return 结束的是 main函数，即最外层的函数。甚至在编译的时候会将 println("main function") 舍弃掉不参与编译，因为它总是不会执行，参与编译毫无意义
那我们在函数类型参数的 lambda 表达式中的return的结果就要看该函数是不是内联函数了，这就让我们敲代码极其的不便利了，每个函数我们都进去看下是否是内联函数，这对我们的时间很大的消耗
后来 Kotlin 官方制定了一条新规则，lambda表达式中不允许直接使用return，除非这个 Lambda 是内联函数的参数，并且结束的是最外层的函数
解决上面的问题我们也可以使用return@label的方式结束代码作用域，例如直接return隐式标签 linpopopo

fun main() {
    linpopopo {
        println("linpopopo function")
        return@linpopopo
    }
    println("main function")
}

inline fun linpopopo(action: () -> Unit) {
    action.invoke()
}

反编译再看下代码

public final void main() {
  int $i$f$linpopopo = false;
  int var3 = false;
  String var4 = "linpopopo function";
  System.out.println(var4);
  String var1 = "main function";
  System.out.println(var1);
}

public final void linpopopo(@NotNull Function0 action) {
  int $i$f$linpopopo = 0;
  Intrinsics.checkNotNullParameter(action, "action");
  action.invoke();
}

干得漂亮，非常符合我们的预期，老板都夸你解决问题的方式多，加鸡腿加鸡腿
再来看下下面这个场景，有的时候我们需要在主线程上面去执行 lambda 表达式，这里主线程是使用协程进行切换

fun main() {
    linpopopo {
        println("linpopopo function")
        return
    }
    println("main function")
}

inline fun linpopopo(action: () -> Unit) {
    MainScope().launch {
        action.invoke()
    }
}

这样会引起一个问题，linpopopo 函数和 main函数就属于间接调用关系，导致 lambda 表达式里的 return 无法结束 main 函数。那么它在这里结束的是谁？其实压根不会结束谁，因为上面这段代码根本不会编译通过，编译器也给出了错误提示

crossinline_warn.png

千呼万唤始出来，编译器让我们使用 crossinline 去修饰函数类型的参数，这样间接调用关系才会成立

inline fun linpopopo(crossinline action: () -> Unit) {
    MainScope().launch {
        action.invoke()
    }
}

我们又回到了原始的问题，加了 crossinline 这里的 lambda 表达式里的 return到底结束了谁？是 main 函数 还是协程 launch作用域呢？
对于这种歧义的问题，Kotlin 官方又增加了一条新的规定，内联函数中被 crossinline 修饰的函数类型的参数不允许return
所以上面的 return 也不会编译成功，当然这里还是可以使用return@label的方式结束代码作用域的

fun main() {
    linpopopo {
        println("linpopopo function")
        return@linpopopo
    }
    println("main function")
}

inline fun linpopopo(crossinline action: () -> Unit) {
    MainScope().launch {
        action.invoke()
    }
}

总结

• inline: 编译时将函数体拷贝到调用的地方，减少函数类型对象的创建
• noinline: 局部关掉内联，解决不能把函数类型的参数当做对象来使用的问题
• crossinline: 局部加强内联，让内联函数中函数类型的参数可以间接被调用，并且 crossinline 修饰的函数类型的参数不允许return

致谢

文中部分观点参考了扔物线大佬的作品，小伙伴可自行查阅哦，扔物线大佬文章很生动哈哈哈
原文地址：Kotlin源码里成吨的noinline和crossinline是干嘛的？看完视频你转头也写了一吨