Kotlin 内联函数

Kotlin 的 inline 关键字主要用来优化高阶函数，通过将函数体在编译时“复制”到调用处，来消除 Lambda 表达式带来的额外对象创建和调用开销。而 noinline 和 crossinline 则为你提供了更精细的控制，用来应对不同的场景。

下面是这三个关键字的详细解释和使用场景。

inline：性能优化的主力

核心作用：消除Lambda开销

高阶函数（接收Lambda作为参数的函数）在运行时，每个Lambda表达式都会被编译成一个Function对象，并可能产生额外的内存分配和虚拟调用开销。inline 关键字正是为了解决这个问题。

当你在一个函数前加上inline，编译器不仅会内联函数本身的代码，还会默认内联所有传递给它的Lambda参数，从而避免这些运行时开销。

// 一个典型的内联高阶函数
inline fun execute(action: () -> Unit) {
    action()
}

fun main() {
    execute {
        println("Hello")
    }
    // 编译后，代码逻辑等价于直接在这里写：println("Hello")
}

主要使用场景

1. 优化高阶函数：这是 inline 最核心、最推荐的使用场景。对于Kotlin标准库中像 repeat、map、filter 等集合操作函数，它们都使用了 inline 来保证性能。
2. 实现具体化的类型参数 (Reified Type Parameters)：这是 inline 的另一个“杀手锏”。普通的泛型函数在运行时无法获取类型信息（类型擦除），但 inline 函数配合 reified 关键字，可以让你在函数内部像使用普通类一样使用泛型参数，进行类型检查和转换。

   // 使用 reified 获取泛型类型信息，无需再传入 Class<T>
   inline fun <reified T> getTypeName(): String {
       return T::class.simpleName ?: "Unknown"
   }
   
   fun main() {
       val typeName = getTypeName<String>() // 可以正常工作，返回 "String"
   }
   

3. 在循环或高频调用的场景：在循环中反复调用高阶函数时，inline 能显著减少创建的对象数量，提升性能。

注意事项：并非万能药

• 代码膨胀：内联会复制代码，如果内联一个体积庞大的函数，会导致生成的字节码急剧增加，反而可能因为CPU缓存命中率降低而影响性能。
• 递归函数不能内联：编译器无法内联递归调用的函数。
• 普通函数不推荐：如果一个函数没有函数类型的参数或 reified 类型参数，编译器会警告你，因为内联这样的大函数几乎不会带来性能提升。

noinline：选择性放弃内联

为什么需要它？

默认情况下，inline 函数会内联所有Lambda参数。但有时，你可能希望某个Lambda 不被内联，比如：你需要把这个Lambda作为一个对象，存储到变量里、传递给另一个非内联函数，或者稍后再使用。

// 使用 noinline 标记 block2，使其不被内联
inline fun foo(block1: () -> Unit, noinline block2: () -> Unit) {
    block1() // 会被内联

    // block2 不会被内联，可以像普通对象一样操作
    val pendingAction = block2
    someNonInlineFunction(pendingAction)
}

fun someNonInlineFunction(action: () -> Unit) {
    // ...
}

使用场景

• 传递Lambda给非内联函数：当内联函数需要将某个Lambda作为参数，传递给一个非内联的函数或保存起来时，必须用 noinline 标记该参数，否则编译器会报错。
• 避免过度内联：如果一个内联函数有多个Lambda参数，但其中一个Lambda体很大且不常使用，你可以用 noinline 阻止它被内联，来控制最终的代码大小。

crossinline：安全的非局部返回

核心作用：禁止非局部返回 (Non-local return)

在 inline 函数的Lambda中，你可以直接使用 return 来从外层函数返回，这被称为“非局部返回”。这很方便，但前提是Lambda是在函数的直接执行上下文中调用的。

但如果这个Lambda被传递到了另一个执行上下文，比如被放在一个Runnable对象里，或者被传递给一个非内联函数，情况就变得复杂了。此时，非局部返回可能会导致意外的行为甚至错误。

crossinline 的解决方案

crossinline 修饰符正是为了解决这个问题。它向编译器承诺：在这个Lambda中，你绝对不能使用非局部返回（return）。这样，你就可以安全地将这个Lambda传递给其他执行上下文了。

// 假设有一个非内联函数
fun runLater(action: () -> Unit) {
    // 模拟异步执行
    Thread.sleep(100)
    action()
}

// 使用 crossinline，保证任务 (task) 中不会非局部返回
inline fun executeTask(crossinline task: () -> Unit) {
    // task 被安全地传递给了非内联函数 runLater
    runLater {
        task()
    }
}

fun main() {
    executeTask {
        println("Task is running")
        // return // 这一行会报错！因为 crossinline 禁止了非局部返回
    }
    // 程序会继续执行到这里
    println("Main continues")
}

如果不用 crossinline，而错误地使用 noinline 来达到编译通过的目的，虽然能编译，但会失去内联带来的性能优化（编译器会有警告）。

总结与对比