美文网首页kotlin入门潜修
kotlin入门潜修之进阶篇—inline方法及其原理

kotlin入门潜修之进阶篇—inline方法及其原理

作者: 寒潇2018 | 来源:发表于2019-01-10 11:49 被阅读0次

    本文收录于 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
    }
    

    没错,上面就是生成的全部字节码!通过字节码可以发现以下两点:

    1. kotlin不再为lambda表达式生成一个新类。
    2. 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方法一样,编译器会在编译的时候会进行检查。

    相关文章

      网友评论

        本文标题:kotlin入门潜修之进阶篇—inline方法及其原理

        本文链接:https://www.haomeiwen.com/subject/ercgrqtx.html