前言
最近，無意中看到一篇文章，是聊inline在高階函數中的性能提升，說實話之前沒有認真關注過這個特性，所以藉此機會好好學習了一番。
高階函數：入參中含有lambda的函數（方法）。
原文是一位外國小哥寫的，這裡把它翻譯了一下重寫梳理了一遍發出來。也算是技術無國界吧，哈哈~
官方文檔對inline的使用主要提供了倆種方式：內聯類、內聯函數
正文
操作符是我們日常Kotlin開發的利器，如果我們點進去看看源碼，我們會發現這些操作符大多都會使用inline。
inlinefun<T> Iterable<T>.filter(predicate: (T)->Boolean): List<T>{val destination = ArrayList<T>()for (element inthis) if (predicate(element))destination.add(element)return destination}
既然官方標準庫中如果使用，我們則需要驗證一下inline是不是真能有更好的性能：
inlinefunrepeat(times: Int, action: (Int) -> Unit) {for (index in0 until times) {action(index) }}funnoinlineRepeat(times: Int, action: (Int) -> Unit) {for (index in0 until times) { action(index) }}
倆個函數，除了inline沒什麼其他區別。接下來咱們執行個100000000次，看看方法耗時：
var a = 0repeat(100_000_000) {a += 1}var b = 0noinlineRepeat(100_000_000) { b += 1}
跑起來我們會發現：inlineRepeat()平均完成了0.335ns，而noinlineRepeat()平均需要153 980484.884ns。是46.6萬倍！看起來inline的確很重要，那麼這種性能改進是沒有成本的嗎？我們什麼時候應該使用inline？接下來咱們就來聊一聊這個問題，不過咱們先從一個基本的問題開始：inline有什麼作用？
inline有什麼用？
簡單來說被inline修飾過的函數，會在調用的時候把函數體替換過來。說起來可能很從抽象，直接看代碼：
publicinlinefunprint(message: Int) {
System.out.print(message)}funmain(args: Array<String>) { print(2) print(2)}
反編譯class之後，我們會看到是這個樣子的：
publicstaticfinalvoidmain(@NotNull String[] args){int message$iv = 2;int $i$f$print = false;System.out.print(message$iv); message$iv = 2; $i$f$print = false; System.out.print(message$iv); }
接下來咱們看看高階函數中的優化repeat(100) { println("A") }，反編譯之後：
for (index in0 until 1000) {println("A")}
看到這我猜大家應該可以理解inline的作用了吧。不過，話又說回來。「僅僅」做了這點改動，會什麼會有如此大的性能提升？解答這個問題，不得不聊一聊JVM是如何實現Lambda的。
Lambda的原理
一般來說，會有倆種方案：
匿名類「附加」類咱們直接通過一個demo來看這倆種實現：
val lambda: ()->Unit = {// body}
對於匿名類的實現來說，反編譯是這樣的：
Function0 lambda = new Function0() {public Object invoke(){// body}};
對於「附加」類的實現來說，反編譯是這樣的：
// Additional class in separate filepublicclassTestInlineKt$lambdaimplementsFunction0{public Object invoke(){// code}}// UsageFunction0 lambda = new TestInlineKt$lambda()
有了上邊的代碼，咱們也就明白高階函數的開銷為什麼這麼大：畢竟每一個Lambda都會額外創建一個類。接下來咱們通過一個demo進一步感受這些額外的開銷：
funmain(args: Array<String>) {var a = 0repeat(100_000_000) { a += 1 }var b = 0 noinlineRepeat(100_000_000) { b += 1 }}
反編譯之後：
publicstaticfinalvoidmain(@NotNull String[] args){int a = 0;int times$iv = 100000000;int var3 = 0;for(int var4 = times$iv; var3 < var4; ++var3) {++a; }final IntRef b = new IntRef(); b.element = 0; noinlineRepeat(100000000, (Function1)(new Function1() {public Object invoke(Object var1){ ++b.element;return Unit.INSTANCE; } }));}
inline的成本
inline並不是沒有任何成本的。其實咱們最上邊看
public inline fun print(message: Int) { System.out.print(message) }
的時候，看反編譯的內容也能看出它得到的成本。
接下來咱們就基於這個print()函數，來對比一下：
fun main(args: Array<String>){print(2) print(2) System.out.print(2)}
反編譯如下：
publicstaticfinalvoidmain(@NotNull String[] args){int message$iv = 2;int $i$f$print = false;System.out.print(message$iv); message$iv = 2; $i$f$print = false; System.out.print(message$iv); System.out.print(2);}
可以看出inline額外生成了一些代碼，這也就是它額外的開銷。因此咱們在使用inline的時候還是需要有一定的規則的，以免適得其反。
最佳實踐
當我們沒有高階函數、沒有使用reified關鍵詞時不應該隨意使用inline，徒增消耗。
尾聲
到此這篇文章就結束了。
但是看了外國小哥這篇文章的時候，的確發現自己有很多內容是有遺漏的。所以接下來如果有機會的話，會繼續寫或者翻譯一些這類「最佳實踐」的文章。