簡(jiǎn)介
kotlin 中，有三個(gè)類(lèi)似的概念餐曹，inline，noinline 和 crossinline敌厘。平時(shí)使用的時(shí)候台猴，很容易混淆。本文會(huì)介紹這三個(gè)概念的用法以及區(qū)別俱两。

inline
inline 就是我們常說(shuō)的內(nèi)聯(lián)饱狂。這個(gè)關(guān)鍵字會(huì)在編譯期間起作用。如果一個(gè)函數(shù)是 inline 的宪彩，那么編譯器會(huì)在編譯的時(shí)候休讳，把這個(gè)函數(shù)復(fù)制到調(diào)用處。這樣做有什么好處呢尿孔？總的來(lái)說(shuō)俊柔，好處有三個(gè)：

第一點(diǎn)，會(huì)減少函數(shù)調(diào)用的次數(shù)活合。我們知道雏婶，雖然函數(shù)調(diào)用的開(kāi)銷(xiāo)很小，但是確實(shí)是有一定的開(kāi)銷(xiāo)的芜辕。尤其是在大量的循環(huán)中尚骄，這種開(kāi)銷(xiāo)會(huì)變得更加明顯。

比如如下代碼：

// Kotlin
fun main(args: Array<String>) {
    multiplyByTwo(5)
}
fun multiplyByTwo(num: Int) : Int {
    return num * 2
}

他進(jìn)行反編譯之后的等價(jià) Java 代碼如下：

// Java
public static final void main(@NotNull String[] args) {
   //...
   multiplyByTwo(5);
}

public static final int multiplyByTwo(int num) {
   return num * 2;
}

可以看到侵续，不加 inline 的方法倔丈，編譯成字節(jié)碼憨闰，然后再反編譯成等價(jià) java 代碼，得到的結(jié)果是一個(gè)普通的方法需五。這個(gè)跟我們的常識(shí)是吻合的鹉动。

但是，當(dāng)我們把方法用 inline 修飾了之后宏邮，會(huì)發(fā)生什么呢泽示？

比如如下代碼中，我們把 multiplyByTwo 用 inline 參數(shù)修飾了一下：

// Kotlin
fun main(args: Array<String>) {
    multiplyByTwo(5)
}
inline fun multiplyByTwo(num: Int) : Int {
    return num * 2
}

反編譯得到的結(jié)果如下：

// Java
public static final void main(@NotNull String[] args) {
   // ...
   int num$iv = 5;
   int var10000 = num$iv * 2;
}

public static final int multiplyByTwo(int num) {
   return num * 2;
}

可以看到蜜氨，inline 中的方法械筛，被復(fù)制到了調(diào)用方。這就是 inline 威力強(qiáng)大的地方飒炎！

第二點(diǎn)埋哟，會(huì)減少對(duì)象的生成。當(dāng)方法中郎汪，有一個(gè)參數(shù)是 lambda 的時(shí)候赤赊，使用 inline 的方法，可以減少對(duì)象的生成煞赢。kotlin 對(duì)于默認(rèn)的 lambda 參數(shù)的處理方式為抛计，把 lambda 轉(zhuǎn)化成一個(gè)類(lèi)，看起來(lái)跟 java 中的匿名內(nèi)部類(lèi)非常相似照筑。

比如吹截，

  // Kotlin
    fun main(args: Array<String>) {
        val methodName = "main"
        multiplyByTwo(5) { result: Int -> println("call method $methodName, Result is: $result") }
    }

    fun multiplyByTwo(num: Int,
                      lambda: (result: Int) -> Unit): Int {
        val result = num * 2
        lambda.invoke(result)
        return result
    }

反編譯之后的結(jié)果有點(diǎn)復(fù)雜：

 public final void main(@NotNull String[] args) {
      Intrinsics.checkParameterIsNotNull(args, "args");
      final String methodName = "main";
      this.multiplyByTwo(5, (Function1)(new Function1() {
         public Object invoke(Object var1) {
            this.invoke(((Number)var1).intValue());
            return Unit.INSTANCE;
         }

         public final void invoke(int result) {
            String var2 = "call method " + methodName + ", Result is: " + result;
            boolean var3 = false;
            System.out.println(var2);
         }
      }));
   }

   public final int multiplyByTwo(int num, @NotNull Function1 lambda) {
      Intrinsics.checkParameterIsNotNull(lambda, "lambda");
      int result = num * 2;
      lambda.invoke(result);
      return result;
   }

觀(guān)察生成的結(jié)果：java 生成了一個(gè) Function1 類(lèi)型的對(duì)象，來(lái)表示這個(gè) lambda朦肘。其中饭弓，F(xiàn)untion1 中的 1 就代表這個(gè) lambda 值需要一個(gè)參數(shù)。類(lèi)似的媒抠，如果是不需要參數(shù)的，那么就是 Function0咏花。這個(gè)生成的結(jié)果趴生，跟我們平時(shí)寫(xiě) java 代碼的時(shí)候使用的匿名內(nèi)部類(lèi)的方式是一樣的。那么昏翰，可想而知苍匆，如果這個(gè) lambda 是在一個(gè)循環(huán)中被調(diào)用的，那么就會(huì)生成大量的對(duì)象棚菊。

既然浸踩，inline 有如上的好處，那么是否有什么“壞處”统求，或者會(huì)造成我們使用不方便的地方呢检碗？

首先是据块，對(duì)于一個(gè) public 的 inline 方法，他不可以引用類(lèi)的私有變量折剃。比如：

    private val happy = true
    
    inline fun testNonPrivateField() {
        println("happy = ${happy}")
    }

如果這么寫(xiě)代碼另假，編譯器會(huì)對(duì) happy 保存。道理也很簡(jiǎn)單：既然 inline 是在編譯期間復(fù)制到調(diào)用方怕犁，那么自然就不能引用類(lèi)的私有變量边篮，因?yàn)檎{(diào)用方很大可能應(yīng)該是“看不見(jiàn)”這個(gè)私有變量的。

其次奏甫，inline 方法會(huì)對(duì)流程造成非常隱晦的影響戈轿。

// Kotlin
fun main(args: Array<String>) {
    println("Start of main")

    multiplyByTwo(5) {
        println("Result is: $it")
        return
    }

    println("End of main")
}

// Java
public static final void main(@NotNull String[] args) {
   String var1 = "Start of main";
   System.out.println(var1);
   int num$iv = 5;
   int result$iv = num$iv * 2;
   String var4 = "Result is: " + result$iv;
   System.out.println(var4);
}

觀(guān)察上面的兩端代碼，我們發(fā)現(xiàn)在反編譯出來(lái)的 java 代碼中阵子，沒(méi)有找到 “End of main”凶杖。為什么呢？原因其實(shí)很簡(jiǎn)單：根據(jù)我們前面知道的款筑，inline 其實(shí)就是把代碼在編譯期間復(fù)制到調(diào)用方智蝠，因此，如果 lambda 中有 return 語(yǔ)句奈梳，那么也會(huì)被原樣復(fù)制過(guò)去杈湾，進(jìn)而，因?yàn)?lambda 中的 return 的影響攘须，導(dǎo)致編譯器認(rèn)為后面的 “End of main” 其實(shí)是不能被訪(fǎng)問(wèn)到的代碼漆撞，于是在編譯期間給去掉了。

所以于宙，小結(jié)一下：inline 關(guān)鍵字的作用浮驳，是把 inline 方法以及方法中的 lambda 參數(shù)在編譯期間復(fù)制到調(diào)用方，進(jìn)而減少函數(shù)調(diào)用以及對(duì)象生成捞魁。

不過(guò)至会，inline 關(guān)鍵字對(duì)于 lambda 的處理有的時(shí)候不是我們想要的。也就是谱俭，有時(shí)我們不想讓 lambda 也被 inline奉件。那么有什么辦法呢？這個(gè)時(shí)候就需要 noinline 關(guān)鍵字了昆著。

noinline
noinline 修飾的是 inline 方法中的 lambda 參數(shù)县貌。noinline 用于我們不想讓 inline 特性作用到 inline 方法的某些 lambda 參數(shù)上的場(chǎng)景。

比如：

    // Kotlin
    fun main(args: Array<String>) {
        val methodName = "main"
        multiplyByTwo(5) {
            result: Int -> println("call method $methodName, Result is: $result")
        }
    }

    inline fun multiplyByTwo(
            num: Int,
            noinline lambda: (result: Int) -> Unit): Int {
        val result = num * 2
        lambda.invoke(result)
        return result
    }

反編譯的結(jié)果是：

 public final void main(@NotNull String[] args) {
      Intrinsics.checkParameterIsNotNull(args, "args");
      final String methodName = "main";
      byte num$iv = 5;
      Function1 lambda$iv = (Function1)(new Function1() {
         // $FF: synthetic method
         // $FF: bridge method
         public Object invoke(Object var1) {
            this.invoke(((Number)var1).intValue());
            return Unit.INSTANCE;
         }

         public final void invoke(int result) {
            String var2 = "call method " + methodName + ", Result is: " + result;
            boolean var3 = false;
            System.out.println(var2);
         }
      });
      int $i$f$multiplyByTwo = false;
      int result$iv = num$iv * 2;
      lambda$iv.invoke(result$iv);
   }

   public final int multiplyByTwo(int num, @NotNull Function1 lambda) {
      int $i$f$multiplyByTwo = 0;
      Intrinsics.checkParameterIsNotNull(lambda, "lambda");
      int result = num * 2;
      lambda.invoke(result);
      return result;
   }

可以看到凑懂， 因?yàn)槭褂昧?noinline 修飾了 lambda煤痕，所以，編譯器使用了匿名內(nèi)部類(lèi)的方式來(lái)處理這個(gè) lambda，生成了一個(gè) Function1 對(duì)象摆碉。

crossinline
是不是有了 inline 和 noinline塘匣，對(duì)于我們開(kāi)發(fā)人員來(lái)講就夠了呢？就滿(mǎn)足了呢兆解？顯然不是的馆铁。考慮一種情況锅睛，我們既想讓 lambda 也被 inline埠巨，但是又不想讓 lambda 對(duì)調(diào)用方的控制流程產(chǎn)生影響。這個(gè)產(chǎn)生影響现拒，可以是有意識(shí)的主動(dòng)控制辣垒，但是大多數(shù)情況下是開(kāi)發(fā)人員的不小心導(dǎo)致的。我們知道 java 語(yǔ)言是一個(gè)編譯型語(yǔ)言印蔬，如果能在編譯期間對(duì)這種 inline lambda 對(duì)調(diào)用方產(chǎn)生控制流程影響的地方進(jìn)行提示甚至報(bào)錯(cuò)勋桶，就萬(wàn)無(wú)一失了。

crossinline 就是為了處理這種情況而產(chǎn)生的侥猬。crossinline 保留了 inline 特性例驹，但是如果想在傳入的 lambda 里面 return 的話(huà)，就會(huì)報(bào)錯(cuò)退唠。return 只能 return 當(dāng)前的這個(gè) lambda鹃锈。

    // Kotlin
    fun main(args: Array<String>) {
        val methodName = "main"
        multiplyByTwo(5) {
            result: Int -> println("call method $methodName, Result is: $result")
            return@multiplyByTwo
        }
    }

如面代碼所示，必須 return@multiplyByTwo瞧预，而不能直接寫(xiě) return屎债。

總結(jié)
inline 關(guān)鍵字的作用，是把 inline 方法以及方法中的 lambda 參數(shù)在編譯期間復(fù)制到調(diào)用方垢油，進(jìn)而減少函數(shù)調(diào)用以及對(duì)象生成盆驹。對(duì)于有時(shí)候我們不想讓 inline 關(guān)鍵字對(duì) lambda 參數(shù)產(chǎn)生影響，可以使用 noline 關(guān)鍵字滩愁。如果想 lambda 也被 inline躯喇，但是不影響調(diào)用方的控制流程，那么就要是用 crossinline惊楼。