Kotlin内联函数inline、noinline、crossinline

简介: 如果一个函数接收另一个函数作为参数,或返回类型是一个函数类型,那么该函数被称为是高阶函数

高阶函数

首先来看下kotlin里的高阶函数定义:如果一个函数接收另一个函数作为参数,或返回类型是一个函数类型,那么该函数被称为是高阶函数

比如下面的代码:

private fun highFuc(name: String, block: (String) -> Unit) {
    block(name)
}

其中highFuc是函数名,函数中传入了2个参数,第一个参数为String类型,第二个参数即是函数类型,->左边的部分用来声明该函数接收什么参数的,多个参数之间用逗号隔开,如果没有参数直接使用()表示就可以了;->右边表示该函数的返回值是什么类型,如果没有返回值直接使用Unit即可。

内联函数

内联函数,顾名思义,就是在编译时将作为函数参数的函数体直接映射到函数调用处,直接用一个例子来说明:

fun requestInfo() {
    getStr()
}

fun getStr() {
    println("inline")
}

很简单,getStr()中打印了一个字符串,然后requestInfo()中调用了getStr()函数,将上述代码转换成java代码之后:

public final void requestInfo() {
   this.getStr();
}

public final void getStr() {
   String var1 = "inline";
   System.out.println(var1);
}

继续,在getStr()的前面加上inline声明,如下:

fun requestInfo() {
    getStr()
}

//普通函数中并不推荐加inline关键字
inline fun getStr() {
    println("inline")
}

转换成java之后:

public final void requestInfo() {
   String var3 = "inline";
   System.out.println(var3);
}

可以看到转换成java之后的代码有明显的区别:加上inline之后,getStr()中的函数内容直接“复制粘贴”到requestInfo()中,即内联到函数调用处了

inline

通过上面的例子,inline的作用就很明显了,就是在编译时直接将函数内容直接复制粘贴到调用处。

我们知道函数调用最终是通过JVM操作数栈的栈帧完成的,每一个方法从调用开始至执行完成的过程,都对应着一个栈帧在虚拟机栈里从入栈到出栈的过程,使用了inline关键字理论上可以减少一个栈帧层级。

那么是不是所有的函数前面都适合加上inline关键字了呢?答案是否定的,其实JVM本身在编译时,就支持函数内联,并不是kotlin中特有的,那么kotlin中什么样的函数才需要使用inline关键字呢?答:高阶函数!

只有高阶函数中才需要inline去做内联优化,普通函数并不需要,如果在普通函数强行加上inline,编辑器会立刻提醒:

Expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types

意思是 内联对普通函数性能优化的预期影响是微不足道的。内联最适合带有函数类型参数的函数

为什么高阶函数要使用inline

inline优化了什么问题呢?因为我们使用的Lambda表示式在编译转换后被换成了匿名类的实现方式。

fun requestInfo() {
    highFuc("inline") { str ->
        println(str)
    }
}

fun highFuc(name: String, block: (String) -> Unit) {
    block(name)
}

转换成java之后:

public final void requestInfo() {
   this.highFuc("inline", (Function1)null.INSTANCE);
}

private final void highFuc(String name, Function1 block) {
   block.invoke(name);
}

public interface Function1<in P1, out R> : Function<R> {
    public operator fun invoke(p1: P1): R
}

所以函数参数最终会转换成interface,并通过创建一个匿名实例来实现。这样就会造成额外的内存开销。为了解决这个问题,kotlin引入inline内联功能,将Lambda表达式带来的性能开销消除。还是上面的例子,这次我们对高阶函数添加inline关键字:

fun requestInfo() {
    highFuc("inline") { str ->
        println(str)
    }
}

//注意:这里添加了inline关键字
inline fun highFuc(name: String, block: (String) -> Unit) {
    block(name)
}

转换成java之后:

public final void requestInfo() {
   String name$iv = "inline";
   System.out.println(name$iv);
}

noinline

当函数被inline标记时,使用noinline可以使函数参数不被内联。

fun requestInfo() {
    highFuc({
        println("noinline")
    }, {
        println("inline")
    })
}

//highFuc被inline修饰,而函数参数block0()使用了noinline修饰
inline fun highFuc(noinline block0: () -> Unit, block1: () -> Unit) {
    block0()
    block1()
}

转换成java之后:

public final void requestInfo() {
   Function0 block0$iv = (Function0)null.INSTANCE;
   block0$iv.invoke();
   
   String var5 = "inline";
   System.out.println(var5);
}

结果也很明显,block0()函数没有被内联,而block()函数被内联,这就是noinline的作用。

如果想在非内联函数Lambda中直接return怎么办?比如我想这么写:

fun requestInfo() {
    highFuc {
        return //错误,不允许在非内联函数中直接return
    }
}

fun highFuc(block: () -> Unit) {
    println("before")
    block()
    println("after")
}

对不起,不允许!会直接在return的地方报'return' is not allowed here错误。 但是可以写成return@highFuc,即:

fun requestInfo() {
    highFuc {
        return@highFuc //正确,局部返回
    }
}

fun highFuc(block: () -> Unit) {
    println("before")
    block()
    println("after")
}

其中return是全局返回,会影响Lambda之后的执行流程;而return@highFuc是局部返回,不会影响Lambda之后的执行流程。如果我就想全局返回,那么可以通过inline来进行声明:

fun requestInfo() {
    highFuc {
        return 
    }
}

inline fun highFuc(block: () -> Unit) {
    println("before")
    block()
    println("after")
}

因为highFuc通过inline声明为内联函数,所以调用方可以直接使用return进行全局返回,执行requestInfo()的结果:

before

可以看到Lambda之后的after并没有被执行,因为是全局返回,当然可以改成return@highFuc局部返回,这样就可以都执行了。

结论:内联函数所引用的Lambda表达式中是可以使用return关键字来进行函数返回的,而非内联函数只能进行局部返回

现在有一种场景,我既想使用inline优化高阶函数,同时又不想调用方打断我的执行流程(因为inline是支持全局return的),貌似冲突了,这时候怎么办呢,这时候就需要crossinline了。

crossinline

允许inline内联函数里的函数类型参数可以被间接调用,但是不能在Lambda表达式中使用全局return返回。

fun requestInfo() {
    highFuc {
        return //错误,虽然是inline内联函数,但Lambda中使用crossinline修饰,所以不允许全局返回了
    }
}

inline fun highFuc(crossinline block: () -> Unit) {
    println("before")
    block()
    println("after")
}

crossinline关键字就像一个契约,它用于保证内联函数的Lambda表达式中一定不会使用return全局返回,这样就不会冲突了。当然return@highFuc局部返回还是可以的。

总结

  • inline:编译时直接将函数内容直接复制粘贴到调用处。
  • noinline:当函数被inline标记时,使用noinline可以使函数参数不被内联。
  • crossinline: 允许内联函数里的函数类型参数可以被间接调用,但是不能在Lambda表达式中使用全局return返回

参考

【1】高阶函数与 lambda 表达式
【2】https://juejin.cn/post/6869954460634841101
【3】重学 Kotlin —— inline,包治百病的性能良药?

相关文章
|
7月前
|
存储 Java 编译器
Kotlin 学习笔记(四)—— 作用域函数、inline 关键字、反引号等 Kotlin 基本用法(下)
Kotlin 学习笔记(四)—— 作用域函数、inline 关键字、反引号等 Kotlin 基本用法(下)
35 0
|
7月前
|
Java Android开发 开发者
Kotlin 学习笔记(四)—— 作用域函数、inline 关键字、反引号等 Kotlin 基本用法(上)
Kotlin 学习笔记(四)—— 作用域函数、inline 关键字、反引号等 Kotlin 基本用法(上)
53 0
|
Java Kotlin
Kotlin学历之内联函数
Kotlin学历之内联函数
80 0
Kotlin学历之内联函数
|
Java Kotlin
Kotlin中内联函数的作用是什么?
在以前,因为学过一段时间Kotlin(并没有实际开发中用过),很多东西都忘记了,但是kotlin的代码看起来其实和Java没什么区别,感觉都差不多。所以不要认为 Kotlin 很难学。
172 0
|
编译器 Kotlin
利用 Kotlin inline 解决日志泄漏风险
利用 Kotlin inline 解决日志泄漏风险
100 0
利用 Kotlin inline 解决日志泄漏风险
|
XML Java Android开发
kotlin 之几个常见的内联函数(六)—— 总结篇
本篇内容对内联函数做了一个总结,分别是let、with、run、apply、also
|
Java Kotlin
kotlin 之几个常见的内联函数(五)
适用于let函数的任何场景,also函数和let很像,只是唯一的不同点就是let函数最后的返回值是最后一行的返回值而also函数的返回值是返回当前的这个对象。一般可用于多个扩展函数链式调用。
144 0
|
XML Java 数据格式
kotlin 之几个常见的内联函数(四)
从结构上来看apply函数和run函数很像,唯一不同点就是它们各自返回的值不一样,run函数是以闭包形式返回最后一行代码的值,而apply函数的返回的是传入对象的本身。
112 0
|
Java Kotlin
kotlin 之几个常见的内联函数(三)
适用于let,with函数任何场景。因为run函数是let,with两个函数结合体,准确来说它弥补了let函数在函数体内必须使用it参数替代对象,在run函数中可以像with函数一样可以省略,直接访问实例的公有属性和方法,另一方面它弥补了with函数传入对象判空问题,在run函数中可以像let函数一样做判空处理
120 0
|
Java Android开发 Kotlin
kotlin 之几个常见的内联函数(二)
with函数它不是以扩展的形式存在的。它是将某对象作为函数的参数,在函数块内可以通过 this 指代该对象。同时this也可以省略,也就是在函数快里面可以直接使用对象的属性活方法。返回值为函数块的最后一行或指定return表达式。
125 0