inline、noinline、crossinline的区别

1、简介：

inline、noinline、crossinline 是 Kotlin 中的三个关键字。在 Kotlin 源码中我们可以发现，这三个关键字被大量使用，那么它们究竟是干嘛的呢？

2. inline

• 2.1 编译时常量

在介绍 inline 之前，我们可以先了解下 Java 中的一个概念：编译时常量 ( Compile-time Constant )。其指变量的值固定不变，在编译时我们就可拿到这个变量的值。具体到代码中，就是变量使用 final 修饰，类型只能是字符串或基本类型，在声明时就赋值；在编译时，会直接拿这个变量值去替换变量名。这样一来，程序结构就变简单了。

• 2.2 inline: 内联函数

上述编译时常量的作用其实就是一种内联优化，而被 inline 标记的函数，被称为内联函数。所谓内联，就是在代码编译时会将被调用处代码直接嵌入到调用处的函数体中。具体示例如下：

// 内联函数
inline fun hello() {
    println("Say Hello!")
}

// 调用函数
fun main() {
    hello()
}

// 实际编译后
fun main() {
    println("Say Hello!")
}

可以看出，inline 的作用与编译时常量的特点非常相似，都可以内嵌代码，我们也可以将此种行为称作代码的展开铺平。如此一来，内联函数就可以减少方法栈的层级，省去了上述示例中 hello() 在方法栈中的占用层级，使得方法栈变浅。

但事实上，减少方法栈的层级，这种优化产生的效果非常小，小到可以忽略不计。而甚至可能因为大量使用 inline，代码到处拷贝，最后使得编译生成的字节码膨胀，成为负优化。那么，inline 到底有何优势呢？

• 2.3 inline: 铺平函数类型参数

我们在平常开发中会经常遇到函数中的参数也是函数类型，如下：

fun hello(block: () -> Unit) {
    println("Say Hello!")
    block()
}

fun main() {
    hello {
        println("Bye!")
    }
}

在 Java 中并没有对函数类型变量的原生支持，此形式是 Kotlin 中的写法。而 Kotlin 为了让其生效，它会创建一个 JVM 对象作为函数类型变量的实际载体去执行变量中的实际代码。也就是说，在 main() 中调用 hello() 时，其实创建了一个对象来执行 hello() 的 Lambda 表达式中的代码，虽然这个对象只是用一下就会被抛弃，但是确实创建了。这就实实在在的产生了资源消耗。而如果 hello() 被循环调用100次，甚至更多，那么内存占用不就一下子上来了吗！那如果给 hello() 加上 inline 会有什么效果呢？

inline fun hello(block: () -> Unit) {
    println("Say Hello!")
    block()
}

fun main() {
    hello {
        println("Bye!")
    }
}

// 实际编译后
fun main() {
    println("Say Hell!")
    println("Bye!")
}

可以看到，如果将 hello() 变为内联函数，编译后不仅将 hello() 自身代码铺平，同时也将 hello() 的 Lambda 表达式中的代码也一块在 main() 中铺平，没有额外创建对象，这样资源消耗也就自然减少了，这就是 inline 非常重要的一个特性：可以将被标记函数的函数类型参数代码一起展开铺平。

• 2.4 正确使用inline

综上可知，inline可以优化代码，但是不能无脑使用，否则会造成字节码膨胀，最直观的体现就是包体积变大。一般我们可以在函数高频调用场景酌情使用，减少内存占用，优化代码执行速度（毕竟铺平的代码要比调用执行的更快），例如处理Socket推送数据的场景。

3. noinline

根据上述内容，我们可知：函数类型参数本质是一个对象，而 inline 函数会将这个对象的代码展开铺平，消除其对象属性。

noinline 字面意思是“不内联”，用于标记 inline 函数中的函数类型参数。被标记的函数类型参数不会被内联，即不会如上示例所述，进行代码铺平，其依旧是个对象。那么关闭内联优化，有什么用呢？我们可以看下面一个例子：

// 错误示例
inline fun hello(block: () -> Unit): () -> Unit {
    println("Say Hello!")
    return block
}

我们有时会碰到返回值就是函数类型参数这种状况，但是 inline 函数已经将 hello() 中的 block 代码铺平，即本来 block 是个对象，现在被 inline优化，直接消除了，那还怎么返回呢？所以上述示例是错误的，同时我们也能在 IDE 中发现 return 直接报错了。这时就轮到 noinline 出场，关闭针对函数类型参数的内联优化，使 block 依然作为一个对象被使用，如此就可以正常 return 了。正确示例如下：

// 正确示例，使用 noinline 标记 block
inline fun hello(noinline block: () -> Unit): () -> Unit {
    println("Say Hello!")
    return block
}

4. crossinline

• 4.1 Lambda中的return

在说 crossinline 之前，我们先看两个示例：

// 示例 1
inline fun hello(block: () -> Unit) {
    println("Say Hello!")
    block()
}

fun main() {
    hello {
        println("Bye!")
        return
    }
    println("Continue")
}

// 示例 2
fun hello(block: () -> Unit) {
    println("Say Hello!")
    block()
}

fun main() {
    hello {
        println("Bye!")
        return@hello
    }
    println("Continue")
}

在示例1中，我们在 inline标记的 hello() 的 Lambda 表达式中加了 return；而在示例2中我们也在 hello() 的 Lambda 表达式中加了 return，但是与示例1不同的是，示例2中的 hello() 并不是内联函数，且 return 后面多了 @hello，即显示的结束 hello()，不允许直接使用 return。我们看下两个示例的打印结果：
示例1的打印结果：

Say Hello!
Bye!

示例2的打印结果：
Say Hello!
Bye!
Continue

可以发现，示例1中 Continue 并没有被打印出来，所以 hello() 的 Lambda 表达式中的 return 其实结束的不是 hello() 本身，而是穿透了 hello() 结束了 main()。而示例2中是正常打印了所有的字符串，即被 return 结束的函数只是 hello()，main() 不受影响。而示例1为何是这样执行？其实原因也很简单！在介绍 inline的时候我们提到过，内联函数的函数类型参数会被展开铺平，那示例1编译后的代码应该如下所示：

inline fun hello(block: () -> Unit) {
    println("Say Hello!")
    block()
}

fun main() {
    hello {
        println("Bye!")
        return
    }
    println("Continue")
}

// 实际编译后
fun main() {
    println("Bye!")
    return
    println("Continue")
}

可以看到，在编译后，main() 中其实是有个 return 的，那么 println("Continue")就自然不会被执行了。但是问题就来了，如果我们在 return 的时候都需要去查看原函数是否被 inline 标记，这也太不科学了吧！所以在 Kotlin 中有一条规则：在 Lambda 表达式中不允许直接使用 return，除非这个 Lambda 是内联函数的参数。 这样规则就简单多了：

1.只有作为内联函数的参数的 Lambda 表达式中可以直接使用 return
2.Lambda 表达式中的 return 结束的不是内联函数自身，而是内联函数的调用函数

• 4.2 内联函数中的间接调用

有这么一个需求，我们需要在UI线程中去执行内联函数中的某个代码块，这个需求应该不过分吧？常规写法一般如下：

// 错误示例
inline fun hello(block: () -> Unit) {
    println("Say Hello!")
    runOnUiThread {
        block()
    }
}

fun main() {
    hello {
        println("Bye!")
        return
    }
    println("Continue")
}

这其实就是在内联函数中间接调用函数类型参数，说“间接”是因为本来 block 的控制权是在 hello() 中，其外层是 hello()，这么一写，控制权就被 runOnUiThread 夺走了，外层变成了 runOnUiThread。而如果此时，我们在 hello() 的 Lambda 表达式中加个 return，那么就会出现一个问题， return 无法结束 main()。因为遵循 inline 规则，最后编译出的代码大致是这样的：

// 编译后
fun main() {
    println("Say Hello!")
    runOnUiThread {
        println("Bye!")
        return
    }
}

非常明显，return 结束的是 runOnUiThread 中的 Runnable 对象，而不是 main()。那这样与之前的规则不就冲突了吗？所以事实上，这种间接调用写法是不被允许的，IDE 会给你一个刺眼的红线。那如果我们一定要间接调用该怎么做呢？这时就轮到 crossinline 出场了，正确示例如下：

// 正确示例
inline fun hello(crossinline block: () -> Unit) {
    println("Say Hello!")
    runOnUiThread {
        block()
    }
}

fun main() {
    hello {
        println("Bye!")
    }
}

我们直接给 block 加上关键字 crossinline，这样就允许间接调用了。但是如果我们还想要在 Lambda 中加上 return 该怎么做呢？那对不起，Kotlin不支持！

基于上述内容，我们可以对 crossinline 进行一个总结。crossinline 字面意思是交叉内联，也是作用于内联函数的函数类型参数上，其用途就是强化函数类型参数的内联优化，使之能被间接调用，并且被 crossinline 标记的 Lambda 中不能使用 return。

5. 总结

inline、noinline、crossinline 使 Kotlin 中常用的三个关键字：

• inline： 内联，用于修饰函数。被修饰的函数称为内联函数，内联函数中的代码可以直接嵌入到调用处，从而减少方法栈的层级与函数类型对象的创建。
• noinline： 不内联，用于修饰内联函数中的函数类型参数，关闭对函数类型参数的内联优化，从而摆脱 inline 带来的「不能把函数类型参数当对象使用」的限制。
• crossinline： 交叉内联，用于修饰内联函数中的函数类型参数，使函数类型参数能被间接调用。

6. 原文链接

• Kotlin源码里成吨的noinline和crossinline是干嘛的？看完视频你转头也写了一吨（文章）
• Kotlin源码里成吨的noinline和crossinline是干嘛的？看完视频你转头也写了一吨（视频）

---

参考链接：https://www.jianshu.com/p/23f8cd32d8dd