Kotlin：你必须要知道的 inline-noinline-crossinline

· 编程学习 · 52898




本文由 jidaoyang 授权投稿
作者博客：https://blog.jiyang.site




在 Kotlin 中使用内联函数时，有时结合这几个关键字可提高程序性能。


概览


inline


使用 inline 声明的函数，在编译时将会拷贝到调用的地方。


inline function


定义一个sum函数计算两个数的和。


fun main(args: Array<String>) {    println(sum(1, 2))}fun sum(a: Int, b: Int): Int {    return a + b}
    println(sum(1, 2))
}

fun sum(a: Int, b: Int): Int {
    return a + b
}


反编译为 Java 代码:


public static final void main(@NotNull String[] args) {   int var1 = sum(1, 2);   System.out.println(var1);}public static final int sum(int a, int b) {   return a + b;}
   int var1 = sum(1, 2);
   System.out.println(var1);
}

public static final int sum(int a, int b) {
   return a + b;
}


正常的样子，在该调用的地方调用函数。


然后为 sum 函数添加 inline 声明:


inline fun sum(a: Int, b: Int): Int {    return a + b}fun sum(a: Int, b: Int): Int {
    return a + b
}


再反编译为 Java 代码:


public static final void main(@NotNull String[] args) {   //...   byte a$iv = 1;   int b$iv = 2;   int var4 = a$iv + b$iv;   System.out.println(var4);}public static final int sum(int a, int b) {   return a + b;}
   //...
   byte a$iv = 1;
   int b$iv = 2;
   int var4 = a$iv + b$iv;
   System.out.println(var4);
}

public static final int sum(int a, int b) {
   return a + b;
}


sum 函数的实现代码被直接拷贝到了调用的地方。


上面两个使用实例并没有体现出 inline 的优势。当你的函数中有 lambda 形参时，inline 的优势才会体现。


inline function with lambda parameters


考虑如下代码，会被编译成怎样的 Java 代码?


fun sum(a: Int, b: Int, lambda: (result: Int) -> Unit): Int {    val r = a + b    lambda.invoke(r)    return r}fun main(args: Array<String>) {    sum(1, 2) { println("Result is: $it") }}Unit): Int {
    val r = a + b
    lambda.invoke(r)
    return r
}

fun main(args: Array<String>) {
    sum(1, 2) { println("Result is: $it") }
}


反编译为 Java:


public static final int sum(int a, int b, @NotNull Function1 lambda) {   //...   int r = a + b;   lambda.invoke(r);   return r;}public static final void main(@NotNull String[] args) {   //...   sum(1, 2, (Function1)null.INSTANCE);}
   //...
   int r = a + b;
   lambda.invoke(r);
   return r;
}

public static final void main(@NotNull String[] args) {
   //...
   sum(1, 2, (Function1)null.INSTANCE);
}




(Function1）null.INSTANCE，是由于反编译器工具在找不到等效的 Java 类时的显示的结果。




我传递的那个 lambda 被转换为 Function1 类型，它是 Kotlin 函数（kotlin.jvm.functions包）的一部分，它以 1 结尾是因为我们在 lambda 函数中传递了一个参数（result：Int)。


再考虑如下代码:


fun main(args: Array<String>) {    for (i in 0..10) {        sum(1, 2) { println("Result is: $it") }    }}
    for (i in 0..10) {
        sum(1, 2) { println("Result is: $it") }
    }
}


我在循环中调用 sum 函数，每次传递一个 lambda 打印结果。反编译为 Java:


for(byte var2 = 10; var1 <= var2; ++var1) {    sum(1, 2, (Function1)null.INSTANCE);}byte var2 = 10; var1 <= var2; ++var1) {
    sum(1, 2, (Function1)null.INSTANCE);
}


可见在每次循环里都会创建一个 Function1 的实例对象。这里就是性能的优化点所在，如何避免在循环里创建新的对象？


    

  1. 

    在循环外部创建 lambda 对象
    

    2. 



val l: (r: Int) -> Unit = { println(it) }for (i in 0..10) {    sum(1, 2, l)}Int) -> Unit = { println(it) }

for (i in 0..10) {
    sum(1, 2, l)
}


反编译为 Java:


Function1 l = (Function1)null.INSTANCE;int var2 = 0;for(byte var3 = 10; var2 <= var3; ++var2) {    sum(1, 2, l);}
int var2 = 0;

for(byte var3 = 10; var2 <= var3; ++var2) {
    sum(1, 2, l);
}


只会创建一个 Function 对象


    

  1. 

    使用 inline:
    

    2. 



fun main(args: Array<String>) {    for (i in 0..10) {        sum(1, 2) { println("Result is: $it") }    }}inline fun sum(a: Int, b: Int, lambda: (result: Int) -> Unit): Int {    val r = a + b    lambda.invoke(r)    return r}
    for (i in 0..10) {
        sum(1, 2) { println("Result is: $it") }
    }
}

inline fun sum(a: Int, b: Int, lambda: (result: Int) -> Unit): Int {
    val r = a + b
    lambda.invoke(r)
    return r
}


反编译为 Java:


public static final void main(@NotNull String[] args) {   //...   int var1 = 0;  for(byte var2 = 10; var1 <= var2; ++var1) {     byte a$iv = 1;     int b$iv = 2;     int r$iv = a$iv + b$iv;     String var9 = "Result is: " + r$iv;     System.out.println(var9);  }}
   //...
   int var1 = 0;

  for(byte var2 = 10; var1 <= var2; ++var1) {
     byte a$iv = 1;
     int b$iv = 2;
     int r$iv = a$iv + b$iv;
     String var9 = "Result is: " + r$iv;
     System.out.println(var9);
  }
}


lambda 代码在编译时被拷贝到调用的地方， 避免了创建 Function 对象。


inline 注意事项


public inline 函数不能访问私有属性


class Demo(private val title: String) {    inline fun test(l: () -> Unit) {        println("Title: $title") // 编译错误: Public-Api inline function cannot access non-Public-Api prive final val title    }    // 私有的没问题    private inline fun test(l: () -> Unit) {        println("Title: $title")    }}private val title: String) {

    inline fun test(l: () -> Unit) {
        println("Title: $title") // 编译错误: Public-Api inline function cannot access non-Public-Api prive final val title
    }

    // 私有的没问题
    private inline fun test(l: () -> Unit) {
        println("Title: $title")
    }
}


注意程序控制流


当使用 inline 时，如果传递给 inline 函数的 lambda，有 return 语句，那么会导致闭包的调用者也返回。


例子:


inline fun sum(a: Int, b: Int, lambda: (result: Int) -> Unit): Int {    val r = a + b    lambda.invoke(r)    return r}fun main(args: Array<String>) {    println("Start")    sum(1, 2) {        println("Result is: $it")        return // 这个会导致 main 函数 return    }    println("Done")}fun sum(a: Int, b: Int, lambda: (result: Int) -> Unit): Int {
    val r = a + b
    lambda.invoke(r)
    return r
}

fun main(args: Array<String>) {
    println("Start")
    sum(1, 2) {
        println("Result is: $it")
        return // 这个会导致 main 函数 return
    }
    println("Done")
}


反编译 Java:


public static final void main(@NotNull String[] args) {   String var1 = "Start";   System.out.println(var1);   byte a$iv = 1;   int b$iv = 2;   int r$iv = a$iv + b$iv;   String var7 = "Result is: " + r$iv;   System.out.println(var7);}
   String var1 = "Start";
   System.out.println(var1);
   byte a$iv = 1;
   int b$iv = 2;
   int r$iv = a$iv + b$iv;
   String var7 = "Result is: " + r$iv;
   System.out.println(var7);
}


反编译之后也能看到，lambda return 之后的代码不会执行。


如何避免?


可以使用 [email protected] 语法，返回到 lambda 被调用的地方。


fun main(args: Array<String>) {    println("Start")    sum(1, 2) {        println("Result is: $it")        [email protected]    }    println("Done")}
    println("Start")
    sum(1, 2) {
        println("Result is: $it")
        return@sum
    }
    println("Done")
}


noinline


当一个 inline 函数中，有多个 lambda 作为参数时，可以在不想内联的 lambda 前使用 noinline 声明.


inline fun sum(a: Int, b: Int, lambda: (result: Int) -> Unit, noinline lambda2: (result: Int) -> Unit): Int {    val r = a + b    lambda.invoke(r)    lambda2.invoke(r)    return r}fun main(args: Array<String>) {    sum(1, 2,            { println("Result is: $it") },            { println("Invoke lambda2: $it") }    )}fun sum(a: Int, b: Int, lambda: (result: Int) -> Unit, noinline lambda2: (result: Int) -> Unit): Int {
    val r = a + b
    lambda.invoke(r)
    lambda2.invoke(r)
    return r
}

fun main(args: Array<String>) {
    sum(1, 2,
            { println("Result is: $it") },
            { println("Invoke lambda2: $it") }
    )
}


反编译 Java:


public static final int sum(int a, int b, @NotNull Function1 lambda, @NotNull Function1 lambda2) {   int r = a + b;   lambda.invoke(r);   lambda2.invoke(r);   return r;}public static final void main(@NotNull String[] args) {   byte a$iv = 1;   byte b$iv = 2;   Function1 lambda2$iv = (Function1)null.INSTANCE;   int r$iv = a$iv + b$iv;   String var8 = "Result is: " + r$iv;   System.out.println(var8);   lambda2$iv.invoke(r$iv);}
   int r = a + b;
   lambda.invoke(r);
   lambda2.invoke(r);
   return r;
}

public static final void main(@NotNull String[] args) {
   byte a$iv = 1;
   byte b$iv = 2;
   Function1 lambda2$iv = (Function1)null.INSTANCE;
   int r$iv = a$iv + b$iv;
   String var8 = "Result is: " + r$iv;
   System.out.println(var8);
   lambda2$iv.invoke(r$iv);
}


第一个 lambda 内联到了调用处，而第二个使用 noinline 声明的 lambda 没有。


crossinline


声明一个 lambda 不能有 return 语句(可以有 [email protected] 语句)。这样可以避免使用 inline 时，lambda 中的 return 影响程序流程。


inline fun sum(a: Int, b: Int, crossinline lambda: (result: Int) -> Unit): Int {    val r = a + b    lambda.invoke(r)    return r}fun main(args: Array<String>) {    sum(1, 2) {        println("Result is: $it")        return  // 编译错误: return is not allowed here    }}fun sum(a: Int, b: Int, crossinline lambda: (result: Int) -> Unit): Int {
    val r = a + b
    lambda.invoke(r)
    return r
}

fun main(args: Array<String>) {
    sum(1, 2) {
        println("Result is: $it")
        return  // 编译错误: return is not allowed here
    }
}








推荐阅读
滴滴开源 Booster：移动APP质量优化框架
是时候更新Android Studio 3.5了！






编程·思维·职场
欢迎扫码关注






  在看也是一种认可






相关推荐：

    

	

		
拥抱kotlin之习惯使用kotlin高阶函数

	

	
这篇文章给大家分享的是有关拥抱kotlin之习惯使用kotlin高阶函数的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。前言kotlin提供了高阶函数这个概念，可以在一些场景提高编码效率一、什么是高阶函数通俗的说和数学里面的高阶函数概念类似，也就是函数里面的参数可以是函数。...

	


        

	

		
如何在Kotlin中实现定义包和函数

	

	
这期内容当中小编将会给大家带来有关如何在Kotlin中实现定义包和函数，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。包名的定义在xxx.kt文件的顶部进行定义，使用package关键字，定义后，引用包内函数或类，使用包前缀:packagecn.jasonmarzw...

	


        

	

		
Kotlin实现多函数接口的简化调用

	

	
对于一个声明了多个方法的接口，我们使用的时候有时仅仅关注于几个关键方法，并不需要实现所有的。可是由于接口调用的语法限制，使得我们不得不在代码中也显示声明实现了那些我们不关心的方法。在Java中也有简化接口调用的方式，比如安卓中ViewPager监听页面切换时的接口PageChangeListener...

	


        

	

		
如何使用kotlin实现一个饼图

	

	
这篇文章给大家分享的是有关如何使用kotlin实现一个饼图的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。先看看做的是什么看完图，我们来整理下思路饼图居中，每块区域都是一个扇形，需要canvas.drawArc根据角度来绘制需要path.arcTo定位到扇形弧度的一半来绘制...

	


        

	

		
Kotlin中扩展函数的实现机制是什么

	

	
这篇文章将为大家详细讲解有关Kotlin中扩展函数的实现机制是什么，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。// JAVA，20多行代码，充斥着findViewById，类型转换，匿名内部类这样的无意义代码 public cl...

	


        

	

		
浅谈Kotlin中的函数

	

	
本文首发于vivo互联网技术微信公众号 链接：https://mp.weixin.qq.com/s/UV23Uw_969oVhiOdo4ZKAw作者：连凌能 Kotlin，已经被Android官方宣布 kotlinfirst 的存在，去翻Android官方文档的时候，发现提供的示例代码已经变成了Ko...

	


        

	

		
Kotlin与Java的异同点有哪些

	

	
这篇文章主要介绍“Kotlin与Java的异同点有哪些”，在日常操作中，相信很多人在Kotlin与Java的异同点有哪些问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Kotlin与Java的异同点有哪些”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！打印日志Java...

	


        

	

		
Kotlin与Java互操作

	

	
1，Kotlin调用Javaimport java.util.* fun demo(source: List<Int>) {     val list = ArrayList<Int>()         for (item in source) {         list...