• kotlin内联函数是什么？

Kotlin里使用关键字 inline 来表示内联函数。其原理就是：在编译时期，把调用这个函数的地方用这个函数的方法体和参数进行替换。

Java 方法执行的内存模型是基于 Java 虚拟机栈的：每个方法被执行的时候都会创建一个栈帧（Stack Frame），用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧入栈、出栈的过程。

也就是说每调用一个方法，都会对应一个栈帧的入栈出栈过程，如果你有一个工具类方法，在某个循环里调用很多次，那就会对应很多次的栈帧入栈、出栈过程。栈帧的创建及入栈、出栈都是有性能损耗的。

比如test方法中，重复调用多次sum方法：

fun test() {
        //多次调用 sum() 方法进行求和运算
        println(sum(1, 2, 3))
        println(sum(100, 200, 300))
        println(sum(12, 34))
    }

    /**
     * 求和计算
     */
    fun sum(vararg ints: Int): Int {
        var sum = 0
        for (i in ints) {
            sum += i
        }
        return sum
    }

为了避免多次调用 sum() 方法带来的性能损耗，最好改为调用一次方法，将方法内的代码插入到调用该方法的地方：

fun test2() {
        var sum = 0
        for (i in arrayOf(1, 2, 3)) {
            sum += i
        }
        println(sum)

        sum = 0
        for (i in arrayOf(100, 200, 300)) {
            sum += i
        }
        println(sum)

        sum = 0
        for (i in arrayOf(12, 34)) {
            sum += i
        }
        println(sum)
    }

用关键字 inline 标记函数，该函数就是一个内联函数。还是原来的 test() 方法，编译器在编译的时候，会自动把内联函数 sum() 方法体内的代码，替换到调用该方法的地方。查看编译后的字节码，会发现 test() 方法里已经没了对 sum() 方法的调用，凡是原来代码里出现 sum() 方法调用的地方，出现的都是 sum() 方法体内的字节码了。

将sum方法加入inline声明，即可实现test2方法同等的效率。

    inline fun sum(vararg ints: Int): Int {
        var sum = 0
        for (i in ints) {
            sum += i
        }
        return sum
    }

参数内联——优化Lambda开销

函数加上inline，不仅会把函数体内联过来，同时会把参数也内联过来。
比如说我们要计算 println("hello") 这段代码执行的时间，如果不加 inline 的话，那么调用 cost 就要创建 Lambda 表达式，函数调用，Jvm会创建变量来作为函数类型变量的实际载体。该匿名类包含了一个invoke方法，作为Lambda的调用方法，每次调用的时候，会创建多个对象，会有性能损耗。可想而知，Lambda虽然简洁，但是会增加额外的开销。

如果该方法在循环中被调用，那是对性能有相当大的隐患的。

cost {
    println("hello")
}
inline fun cost(block: () -> Unit) {
    val start = System.currentTimeMillis()
    block()
    println(System.currentTimeMillis() - start)
}

  val start = System.currentTimeMillis()
    println("hello")
    println(System.currentTimeMillis() - start)

加上 inline 之后，cost 函数的调用开销没了，Lambda 表达式的创建开销也没了，这就是内联函数的作用，主要是对高阶函数的性能优化。

kotlin中的不少高阶函数，扩展函数都使用了lambda作为参数，都用了inline来修饰，标识为内联函数。

public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

noinline ：避免参数被内联

如果一个内联函数的参数里包含 lambda表达式，也就是函数参数，那么该形参也是 inline 的，举个例子：

如下的例子，会在preAction和afterAction上报错，因为要使用这个匿名函数做为对象使用，导致被内联的函数用不了，会提示参数需要noinline处理。

    inline fun noinlie(preAction:() -> Unit, afterAction:() -> Unit) {
        preAction
        Log.i("minfo", "Hello")
        afterAction
    }

调用：

        noinlie({Log.i("minfo", "preAction")}, {Log.i("minfo", "afterAction")})

crossinline

非局部返回在某些场合下非常有用，但可能存在风险，内联的函数所接收的Lambda参数常常来自于上下文的其他地方。为了避免带有return的Lambda参数产生破坏，可以使用crossinline 关键字来修饰该参数。

如下的内联函数

    inline fun crossInline(crossinline  afterAction:() -> Unit) {
        Log.i("minfo", "Hello")
        afterAction
    }

如果在内联函数的高阶函数加了return

        crossInline {
            Log.i("minfo", "bye")
            return
        }

那就会造成问题，因为参数也被铺平了，代码成为

        crossInline {
            Log.i("minfo", "Hello")
            Log.i("minfo", "bye")
            return
        }

整个大的方法就被返回了，return层级发生了改变。

参考：Kotlin总结之内联函数

https://www.bilibili.com/video/BV1kz4y1f7sf/?spm_id_from=333.337.search-card.all.click&vd_source=40c24e77b23dc2e50de2b7c87c6fed59