本文收录于 kotlin入门潜修专题系列,欢迎学习交流。
创作不易,如有转载,还请备注。
内联方法
在学习c/c++语言的时候,会了解到inline(内联)方法。java中并没有inline方法,而kotlin提供了该功能,这是有别于java的一个地方。kotlin中使用inline关键字来修饰内联方法。
什么是inline方法?使用inline修饰的方法和普通方法有什么区别?这背后的原理是什么?这就是本篇文章要阐述的内容。
先来看下没有使用inline修饰的方法,如下所示:
class Test {
//定义了一个普通的方法m1,该方法打印语句hello world
fun m1() {
println("hello world")
}
//测试方法test,仅仅调用m1
fun test() {
m1()
}
}
上面代码就是一个普通的代码调用,来看看其背后的字节码实现(这里主要来看下test方法的实现):
public final test()V
L0
LINENUMBER 13 L0
ALOAD 0
//注意这里,编译器会通过字节码指令INVOKEVIRTUAL
//来完成方法m1的调用
INVOKEVIRTUAL Test.m1 ()V
L1
LINENUMBER 15 L1
RETURN
L2
LOCALVARIABLE this LTest; L0 L2 0
MAXSTACK = 1
MAXLOCALS = 1
上面注释已经说明了普通方法的调用流程,即会通过字节码指令完成方法的调用,那么inline方法会有什么不同呢?看个inline方法的示例:
class Test {
//此时方法m1就是内联方法,使用了inline关键字修饰
inline fun m1() {
println("hello world")
}
//测试方法
fun test() {
m1()
}
}
上述代码仅仅将方法m1使用了inline关键字来修饰,其他什么都没有变,来看看其背后对应的字节码:
public final test()V
L0
LINENUMBER 13 L0
ALOAD 0
ASTORE 1
L1
LINENUMBER 101 L1
LDC "hello world"//注意这里
ASTORE 2
L2
//同样也注意这里
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 2
INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
L3
L4
LINENUMBER 102 L4
NOP
//省略部分字节码
从字节码可以发现,inline方法被直接编译到了调用处,是作为调用方法的一部分来实现的,而不是通过方法调用来完成的,这就是inline方法和普通方法的区别!
那么,为什么要这么做呢?答案是显而易见的,因为方法调用是有性能开销的,而inline方法刚好可以将方法调用编译到自己的方法体实现中,故节省了很多开销。
如果,你觉得方法开销不必在意的话,那么就来看下面一段代码:
class Test {
//方法m0接收了一个方法类型作为参数
fun m0(checkStr: (str: String) -> String) {
val str1 = "test str"
println(checkStr(str1))
}
fun test() {
m0({ "test2" })
}
}
如果看过kotlin入门潜修之进阶篇—高阶方法和lambda表达式
这篇文章,一定对上面的代码不陌生,这就是kotlin中的高阶方法!在kotlin入门潜修之进阶篇—高阶方法和lambda表达式原理
这篇文章中,我们曾分析过,方法类型实际上最终都是以对象的形式存在的,kotlin会为lambda表达式生成一个新类,并通过该类的实例完成方法的入参及执行。所以这中间存在着一些内存方面的开销,如果有很多这种语句,那么这个开销将会变的非常之大。
下面我们将m0方法改成inline方法进行实现,源代码如下所示:
class Test {
//m0方法使用了inline关键字来修饰,表示m0是个内联方法
inline fun m0(checkStr: (str: String) -> String) {
val str1 = "test str"
println(checkStr(str1))
}
fun test() {
m0({ "test2" })
}
}
上面代码将m0标注为了inline方法,来看下其背后对应的字节码,如下所示:
// ================Test.class =================
// class version 50.0 (50)
// access flags 0x31
public final class Test {
// access flags 0x11
// signature (Lkotlin/jvm/functions/Function1<-Ljava/lang/String;Ljava/lang/String;>;)V
// declaration: void m0(kotlin.jvm.functions.Function1<? super java.lang.String, java.lang.String>)
public final m0(Lkotlin/jvm/functions/Function1;)V
@Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
L0
ALOAD 1
LDC "checkStr"
INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
L1
LINENUMBER 3 L1
LDC "test str"
ASTORE 3
L2
LINENUMBER 4 L2
ALOAD 1
ALOAD 3
INVOKEINTERFACE kotlin/jvm/functions/Function1.invoke (Ljava/lang/Object;)Ljava/lang/Object;
ASTORE 4
L3
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 4
INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
L4
L5
LINENUMBER 5 L5
RETURN
L6
LOCALVARIABLE str1 Ljava/lang/String; L2 L6 3
LOCALVARIABLE this LTest; L0 L6 0
LOCALVARIABLE checkStr Lkotlin/jvm/functions/Function1; L0 L6 1
LOCALVARIABLE $i$f$m0 I L0 L6 2
MAXSTACK = 2
MAXLOCALS = 5
// access flags 0x11
public final test()V
L0
LINENUMBER 8 L0
ALOAD 0
ASTORE 1
L1
LINENUMBER 95 L1
LDC "test str"
ASTORE 2
L2
LINENUMBER 96 L2
ALOAD 2
ASTORE 3
L3
LINENUMBER 8 L3
LDC "test2"
L4
L5
ASTORE 3
L6
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 3
INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
L7
L8
LINENUMBER 97 L8
NOP
L9
LINENUMBER 9 L9
RETURN
L10
LOCALVARIABLE it Ljava/lang/String; L3 L5 3
LOCALVARIABLE $i$a$1$m0 I L3 L5 4
LOCALVARIABLE str1$iv Ljava/lang/String; L2 L9 2
LOCALVARIABLE this_$iv LTest; L1 L9 1
LOCALVARIABLE $i$f$m0 I L1 L9 5
LOCALVARIABLE this LTest; L0 L10 0
MAXSTACK = 2
MAXLOCALS = 6
// access flags 0x1
public <init>()V
L0
LINENUMBER 1 L0
ALOAD 0
INVOKESPECIAL java/lang/Object.<init> ()V
RETURN
L1
LOCALVARIABLE this LTest; L0 L1 0
MAXSTACK = 1
MAXLOCALS = 1
}
没错,上面就是生成的全部字节码!通过字节码可以发现以下两点:
- kotlin不再为lambda表达式生成一个新类。
- m0方法的实现会被编译到其调用处(即test方法)中。
由此可见,inline方法会节省掉使用lambda或者匿名方法时所带来的内存开销。这就是inline方法背后的优势。
noinline
当inline作用于方法时,会同时对方法本身以及传入的lambda起作用,换句话说,inline方法和lambda都会被编译到方法的调用处(可以见上例),那么如果我们只需要一部分方法被内联该如果做呢?这就是noinline关键字的作用!使用noinline关键字表明其修饰的部分不需要内联到调用处,如下所示:
//代码同上个例子基本一致
class Test {
//唯一不一样的地方就是我们使用noinline修饰了m0方法
//的类型入参
inline fun m0(noinline checkStr: (str: String) -> String) {
val str1 = "test str"
println(checkStr(str1))
}
//测试方法
fun test() {
m0({ "test2" })
}
}
那么这么写以后,kotlin会怎么处理呢?通过查看字节码可知,kotlin会忽略加在方法开头的inline修饰符,而照例为传入的lambda表达式生成了一个新类!但是m0方法体中的实现却被内联到了test方法中,字节码摘录如下:
//test方法对应的字节码
public final test()V
L0
LINENUMBER 8 L0
ALOAD 0
ASTORE 1
GETSTATIC Test$test$1.INSTANCE : LTest$test$1;
CHECKCAST kotlin/jvm/functions/Function1
ASTORE 2
L1
LINENUMBER 95 L1
LDC "test str"//由此可知,m0方法体中代码被内联到了此处
ASTORE 3
L2
LINENUMBER 96 L2
ALOAD 2
ALOAD 3
//这里,可以看出,是通过方法调用来完成lambda表达式功能的
INVOKEINTERFACE kotlin/jvm/functions/Function1.invoke (Ljava/lang/Object;)Ljava/lang/Object;
ASTORE 4
L3
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 4
INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
L4
//下面是kotlin为lambda表达式生成的新类
final class Test$test$1 extends kotlin/jvm/internal/Lambda implements kotlin/jvm/functions/Function1 {
//省略了类中的内容
}
非局部返回(Non-local returns)
先来看个例子:
//定义了一个高阶方法m0,该方法接收一个方法类型
fun m0(param: () -> Unit) {
}
//测试方法
fun test() {
//调用m0方法
m0 {
return// !!!错误,编译不通过!
}
}
上述代码将会编译不通过!原因是return一般会结束方法,表示方法执行完成,而lambda表达式则无法结束方法,也就是不能在lambda表达式中使用return语句。那么如果我们想要结束lambda的执行该如何做呢?那就是使用label机制,如下所示:
fun test() {
m0 {
return@m0//通过隐式的label返回
}
}
隐式的label就是不给m0指定label标识,而是通过默认的方法名m0进行返回。需要注意,上面的return@m0是一个整体,不能有任何空格。使用label后就可以从lambda中返回,然后继续执行方法体下面的语句。
那么如果不使用label还有什么办法吗?有,使用inline方法即可,如下所示:
//将m0标识为了inline方法
inline fun m0(param: () -> Unit) {
}
//测试方法
fun test() {
m0 {
return//正确!
}
}
为什么inline方法可以运行return呢?这是正是因为inline方法是会被编译到调用处的方法体中,所以可以使用return。但这也同时意味着,return语句会直接结束掉整个方法的执行,而不会再执行后面的语句。
这也是使用return@label和使用inline return的区别:前者仅仅是从当前label作用域返回,后者则会返回整个方法。
使用inline方法返回的这种形式,就被称为非局部返回。其定义为:位于lambda表达式内,但是可以通过return直接结束其所属方法的执行。
inline修饰的方法都可以用作非局部返回。kotlin标准库中有很多inline方法,如最常用的forEach方法。这些方法都可以用在非局部返回场景中。
//kotlin库定义的forEach方法,是个inline方法
public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
for (element in this) action(element)
}
举个forEach非局部返回的使用场景:比如我们需要实现遇到偶数就结束方法运行的功能,如下所示:
fun test() {
listOf(1, 2, 3).forEach {
if (it % 2 == 0) {//当遇到偶数时就直接返回
println(it)
return
}
println(it)
}
}
上面代码会打印1 2。即当遇到偶数时就直接返回了整个方法。如果forEach不是inline方法,则无法这么使用。
crossinline
来看一个例子:
//定义了一个inline高阶方法m0,接收一个方法类型作为入参
inline fun m0(checkStr: () -> Unit) {
object : Runnable {
override fun run() {
checkStr()//!!!编译错误
}
}.run()
}
上面代码的场景是这样的:我们不是在inline方法体中直接使用lambda表达式,而是在其方法体内部的匿名对象中使用了lambda表达式。这种场景编译器会报错,不允许这么做!其实想想也是有道理的,因为如果允许checkStr非局部返回的话,那么就会直接结束整个run方法,这可能会带来难以预料的错误。针对这种情况kotlin提供了一个关键字crossinline,使用crossinline修饰的lambda表达式可以应用于方法体的任何地方,如下所示:
inline fun m0(crossinline checkStr: () -> Unit) {
object : Runnable {
override fun run() {
//由于checkStr被使用了crossinline关键字修饰
//所以可以这么用
checkStr()
println("end")
}
}.run()
}
具体化类型参数(Reified type parameters)
kotlin中也有反射,kotlin允许使用反射来访问类型信息,示例如下:
//根据类型获取对应的值,如果匹配我们的类型则返回对应类型的默认值
fun <T> getIntDefValByType(clazz: Class<T>): T? {
val defVal = 0//Int的默认值为0
if (clazz.isInstance(defVal)) {//如果传入的是Int则返回defVal
return defVal as T?
}
return null//如果不是Int则返回null
}
//测试方法main
fun main(args: Array<String>) {
println(getIntDefValByType(Int::class.javaObjectType))//打印 0
println(getIntDefValByType(String::class.javaObjectType))//打印null
}
上面方法的功能是根据获取Int类型的默认值,如果是类型匹配则返回其默认值0,否则返回null。::class表示获取kotlin中的类型信息,而::class.javaObjectType表示获取java对应的类型信息(也可以使用::class.java,但是::class.java无法返回包裹类型对应的类型信息,而javaObjectType可以),这个方法不具有实际意义,但是说明kotlin支持使用反射来进行类型校验。
上述代码虽然能完成功能,但是使用起来不太优雅,我们还要传入具体的类型,那么有没有更优雅的使用方法?当然有,这就是使用reified关键字。示例如下:
//方法需要使用inline修饰,加上了reified 关键字,
//此时方法不需要Class类型的入参
inline fun <reified T> getIntDefValByType2(): T? {
val defVal = 0
if (defVal is T) {//在这里判断是否是T类型即可
return defVal
}
return null
}
//测试方法main
fun main(args: Array<String>) {
println(getIntDefValByType2<Int>())//打印 0
println(getIntDefValByType2<String>())//打印 null
}
上面就是reified的用法,其对应的调用形式就显得相对优雅些。最后需要注意的是,reified关键字只能用于inline方法中!
那么reified背后的原理是什么?为什么我们使用reified就无法进行类型判断?
对于泛型,前面kotlin入门潜修之类和对象篇—泛型及其原理这篇文章已经阐述的很详细:kotlin中的泛型同java一样,都会在运行期进行类型擦除,所以我们使用"is T"这种方法来判断类型的时候是不可能的,因为运行时根本就不存在所谓的T类型。那么reified关键字背后又做了什么?
我们来看下reified的背后的字节码实现,首先先把源代码粘贴出来,如下所示:
//要分析的源代码
inline fun <reified T> getIntDefValByType2(): T? {
val defVal = 0
if (defVal is T) {
return defVal
}
return null
}
//测试代码
fun main(args: Array<String>) {
getIntDefValByType2<Int>()//该语句符合getIntDefValByType2所需类型Int(defVal类型)
getIntDefValByType2<String>()//该语句不符合getIntDefValByType2所需的类型Int(defVal类型)
在来看下其对应的字节码,这里摘录重点的一部分,如下所示:
//这里只摘录了main方法中对应的一部分代码,
LINENUMBER 121 L9
ILOAD 1
INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
INSTANCEOF java/lang/String
IFEQ L10
上面字节码摘录了main方法对应的字节码,其实main方法总共就两句源代码,一句是getIntDefValByType2<Int>(),一句是getIntDefValByType2<String>()。因为getIntDefValByType2方法是inline的,所以getIntDefValByType2的实现会被编译到main方法当中。但是通过字节码发现,getIntDefValByType2<String>()语句会加上一句类型判断,即上面粘贴出来的字节码:INSTANCEOF java/lang/String。而getIntDefValByType2<Int>却没有对应的字节码语句。这说明了什么?
是时候总结下reified背后的原理了。reified实际上是作用在编译期间的,由于reified必须用于inline方法中,而对于inline方法实际上是编译到当前代码的调用处,所以在编译的时候编译器就能根据defVal来确认其对应的具体类型了。当T被传入多个类型时(比如Int、String等等),kotlin就会在编译的时候插入INSTANCEOF字节码指令进行类型判断,INSTANCEOF指令会检测是否是指定类的实例,在本例中,如果是则返回defVal,否则返回null。而在INSTANCEOF判断之前,还有一句字节码指令: INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
这句指令表示将Int的值转为java下的Integer类型,并获取其值,这样才有后面INSTANCEOF指令的判断。
内联属性(inline properties)
从kotlin1.1之后,inline关键字可以用于没有后备字段的属性上,如下所示:
class Test {
val t0: Int = 2//正确,普通的常量(变量定义)
val t1: Int//正确,可以使用inline修饰get
inline get() = 1
var t2: Int//正确
inline get() = 1
set(value) {}
var t3: Int//正确
inline get() = 3
inline set(value) {}
var t4: Int//正确
get() = 1
set(value) {}
var t5: Int//!!!错误,这里显示使用了field字段
inline get() = 3
inline set(value) {
field = value
}
inline val t6 = 1//!!!错误,这里默认使用了field字段
inline var t7 = 2//!!!错误,这里默认使用了field字段
inline var t8: Int//!!!正确,我们复写了get和set,就没有了field字段
get() = 1
set(value) {}
}
上述代码比较容易理解,只需要记住只要有field字段就无法使用inline关键字即可。关于什么时候有field字段,什么时候没有,可记住一句话:只有使用默认的getter(setter)以及显示使用field字段的时候,后备字段才会存在。具体可参见另一篇文章:kotlin入门潜修之类和对象篇—属性和字段
那么inline属性有什么作用?答案是显而易见的:inline属性同inline方法一样会被编译器编译到其调用处,避免了一些开销。
公有内联方法的限制
使用inline方法会有一个潜在的问题,那就是当一个模块调用其他模块的公有inline方法时,由于inline方法会被编译到调用处,所以可能会存在其他模块方法变更,而当前模块没有重新编译的问题。这种问题主要是使用了非公有的inline方法引起的(即公有的inline方法调用了非公有的inline方法),所以kotlin就限制公有的inline方法不能调用非公有的inline方法。如下所示:
//私有inline方法
private inline fun m0() {}
//默认为public的共有inline方法
inline fun m1() {}
//internal inline方法
internal fun m2() {}
//使用@PublishedApi修饰的internal inline方法
@PublishedApi
internal fun m3() {}
//测试方法
inline fun test() {
m0()//错误,public inline方法无法调用private inline方法
m1()//正确,public inline方法可以调用public inline方法
m2()//错误,public inline方法无法调用internal inline方法
m3()//正确,public inline方法可以调用使用@PublishedApi注解标注的internal inline方法,具体见下面解释。
}
这里所说的非公有的inline方法是指使用private和internal修饰的方法。而对于internal修饰的方法,如果用户使用了@PublishedApi注解进行了标识,则可以被public inline方法使用,因为使用@PublishedApi注解标识的方法,同public修饰的inline方法一样,编译器会在编译的时候会进行检查。
网友评论