kotlin - inline、noinline、crossinline使用

kotlin - inline、noinline、crossinline使用

inline 内联函数：用inline关键字标记的函数，避免函数调用的开销，消除 Lambda 带来的运行时开销

noinline禁止内联：一个高阶函数接收了两个或者更多的函数类型的参数，就用加上inline。如果只想内联一个函数，另一个函数就要用noinline

crossinline：使用crossinline防止非局部返回，关键字防止传递给内联函数的 Lambda 进行非局部返回。当一个参数被标记为 crossinline 时，编译器确保 Lambda 不能从调用函数返回。

例子：

/**
 * Author : wn
 * Email : [email protected]
 * Date : 2024/11/3 15:01
 */
class TestInline {

    @Test
    fun test(){
        //testInline()
        //testMyOperation()
        testPerformSafeOperation()
    }

    /**
     * Lambda 表达式在底层被转换成了匿名类的实现方式 - 系统开销比较大
     * 内联函数就是用来消除 Lambda 表达式所带来的运行时开销
     */
    private fun testInline(){
        val num1 = 8
        val num2 = 6
        val result = testAdd1(num1, num2) {n1, n2 ->
            n1 + n2
        }
        println("testAdd1 不是内联函数 ： ${result}")

        //funAdd2方法只是多加了inline
        val result2 = funAdd2(num1, num2) {a , b ->
            a - b
        }

        println("testAdd2 不是内联函数实现： ${result2}")

        inlineTest2 { i, i2 ->
            i + i2
        }

        inlineTest3 {
            println("没啥用")
        }

        var result41 = inlineTest4 { a ->
            "内联函数：接收一个参数 ：${a}"
        }
        println("内联函数：$result41")

        var result5 = runMyRunnable {
            "内联函数 runMyRunnable：${it}"
        }
        println("内联函数 result5：$result5")
    }

    /**
     * 高阶函数
     */
    private fun testAdd1(num1 : Int, num2 : Int, myOperation : (Int, Int) -> Int) : Int{
        val result = myOperation(num1, num2)
        return result
    }

    /**
     * 内联函数, 只要在定义高阶函数是加上 inline 关键字的声明即可
     */
    private inline fun funAdd2(a : Int, b : Int, myOperation : (Int, Int) -> Int) : Int{
        var result = myOperation(a, b)
        return result
    }

    private inline fun inlineTest(block1 : () -> Unit, noinline block2: () -> Unit) {

    }

    private inline fun inlineTest2(block1 : (Int, Int) -> Int){
        var result = block1(8, 9)
        println("inlineTest2 result : ${result}")
    }

    private inline fun inlineTest3(block1 : () -> Unit){
        block1()
    }

    private inline fun inlineTest4(block41 : (Int) -> String) : String{
        block41(41)
        return "inlineTest4 返回：${41}"
    }

    private fun runMyRunnable(block :(Int) -> String) : String{
        val myRunnable = Runnable {
            block(88)
        }
        myRunnable.run()
        return myRunnable.toString()
    }

    /**
     * 测试非局部返回
     */
    private fun testMyOperation(){
        performOperation {
            println("执行performOperation 33")
            return  //非局部返回，不执行'执行testMyOperation 44'语句，直接跳出testMyOperation方法
        }
        println("执行testMyOperation 44")
    }

    private inline fun performOperation(myOperation:() -> Unit){
        println("执行 performOperation 1")
        myOperation()
        println("执行 performOperation 2")
    }

    private fun testPerformSafeOperation(){
        performSafeOperation {
            println("执行 performSafeOperation cc")
            return@performSafeOperation //只能是return@performSafeOperation， 不能直接return，因为添加了crossinline
        }
        println("执行 performSafeOperation dd")
    }

    /**
     * crossinline 关键字防止传递给内联函数的 Lambda 进行非局部返回。当一个参数被标记为 crossinline 时，编译器确保 Lambda 不能从调用函数返回。
     */
    private inline fun performSafeOperation(crossinline myOperation : () -> Unit){
        println("执行 performSafeOperation aa")
        myOperation()
        println("执行 performSafeOperation bb")
    }

}