kotlin入门潜修之进阶篇—inline方法及其原理
本文收录于 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方法一样,编译器会在编译的时候会进行检查。
