内联函数产生原因和原理

为什么要内联函数

• 因为: Kotlin为了书写简单，所以引入了lambda。

• 但是: lambda会造成性能消耗。

• 所以: 引入了内联函数来解决这个问题。

如何证明lambda书写简单

我们来实现个需求，diff一下有lambda和无lambda的代码便知。

需求: 实现一个函数回调，回调一个String给我。

Java版本(无lambda):

// 首先需要定义一个回调

public interface Action {

    void click(String fuck);

}


// 然后定义这个方法，参数就是回调的接口

public void func(Action action) {

    String str = "hello";

    action.click(str);

}


// 最后调用它

public static void main(String[] args) {

    // 这里需要创建一个匿名类

    func(new Action() {

        @Override

        public void click(String fuck) {

            System.out.println(fuck);

        }

    });

}

然后我们来看kotlin版:

// 直接定义方法，参数是个表达式函数

fun func(action: (String) -> Unit) {

    val str = "hello"

    action.invoke(str)

}


// 调用

fun main() {

    // 参数直接传入lambda就完事，it是lambda的默认参数

    func { println(it) }

}

没有对比就没有伤害，java费了十牛三虎之力写了好几行，kotlin短短几行就实现了，这就是lambda的优点: 简洁省事。其实说白了就是：不用创建对象了。

虽然可读性差了点，管它呢，反正看不懂也是别人的事，别人读不懂才能凸显我的不可替代性。

事实证明，lambda确实大大简化了代码的书写过程，我们不用敲创建对象的代码了。

那么，lambda有什么缺点呢？

lambda的缺点

lambda的最大缺点就是性能损耗！

让我们反编译上述kotlin代码来看:

// 这个参数已经被替换成Function1了，这个Function1是kotlin中定义的一个接口

public static final void func(@NotNull Function1 action) {

    Intrinsics.checkNotNullParameter(action, "action");

    String str = "hello";

    action.invoke(str);

}


// main函数

public static final void main() {

    // 这里其实是创建了一个匿名类

    func((Function1)null.INSTANCE);

}

我们看到，kotlin中的lambda最终会在编译期变成一个匿名类，这跟java好像没什么区别啊，都是生成一个匿名类。为什么说kotlin的lambda效率低，因为:kotlin创建匿名类是在编译期。

而java在1.7之后就引入了invokedynamic指令，java中的lambda在编译期会被替换为invokedynamic指令，在运行期，如果invokedynamic被调用，就会生成一个匿名类来替换这个指令，后续调用都是用这个匿名类来完成。

说白了，对于java来说，如果lambda不被调用，就不会创建匿名类。而对于kotlin来说，不管lambda是否被调用，都会提前创建一个匿名类。这就等价于：java把创建匿名类的操作后置了，有需要才搞，这就变相节省了开销。因为创建匿名类会增加类个数和字节码大小。

那么，kotlin为什么不也这么干呢，为什么非要在编译时 就提前做 将来不一定用到的东西呢？因为kotlin需要兼容java6，java6是目前Android的主要开发语言，而invokedynamic又是在java7之后引入的...，mmp！

那么，kotlin怎么擦好这个屁股呢？使用内联函数！

内联函数的实现原理

还是上述代码，我们把func改成内联的，如下:

fun main() {

    func { print(it) }

}


// 方法用inline修饰了

inline fun func(action: (String) -> Unit) {

    val str = "hello"

    action.invoke(str)

}

同样，我们反编译下看看:

// 这个函数没变化

public static final void func(@NotNull Function1 action) {

    Intrinsics.checkNotNullParameter(action, "action");

    String str = "hello";

    action.invoke(str);

}


// 哦，调用方变了：直接把func函数体拷贝过来了，six six six

public static final void main() {

    String str$iv = "hello";

    System.out.print(str$iv);

}

我们看到，添加了inline后，kotlin会直接把被调用函数的函数体，复制到调用它的地方。

这样就不用创建匿名对象了！而且，还少一次调用过程。因为调用匿名对象的函数，本身还多一次调用呢。比如:

// 内联前

public void test(){

    A a = new a();

    a.hello(); //  这里调用一次hello()

}


// 内联后

public void test(){

    // a.hello()的代码直接拷贝进来，不用调hello()了！

}

所以，内联牛逼，万岁万岁万万岁。

但是，内联也有缺点！比如，我现在有个内联函数test()，里面有1000行代码，如果有10个地方调用它，那么就会把它复制到这10个地方，这一下就是10000行。。。这就导致class文件变相增大，进而导致apk变大，用户看见就不想下了。

怎么办呢，那就不内联！也就是说：根据函数的大小，以及被调用次数的多少，来决定是否需要内联。

这是个业务的决策问题，这里不再废话。

内联函数的其他规则

好，我们来看下内联函数的一些规则。

内联函数的局限性

内联函数作为参数，只能传递给另一个内联函数。比如:

// func2是非内联的

fun func2(action: (String) -> Unit) {


}


// func是内联的

inline fun func(action: (String) -> Unit) {

    val str = "hello"

    action.invoke(str)


    // action此时是内联的，传递给非内联函数func2，就会报错

    func2(action) // 报错

}

现在我们讲func2改为内联的:

// 将func2改为内联

inline fun func2(action: (String) -> Unit) {


}


// func是内联的

inline fun func(action: (String) -> Unit) {

    val str = "hello"

    action.invoke(str)


    // 将action传递给另一个内联函数func2，正常

    func2(action) // ok

}

如果，不希望修改func2()为内联的怎么办呢，此时可以使用noinline修饰action参数:

// func2是非内联的

fun func2(action: (String) -> Unit) {


}


// func是内联的，但是action被标记为非内联的

inline fun func(noinline action: (String) -> Unit) {

    val str = "hello"

    action.invoke(str)


    // action此时是非内联的，可以传递给非内联函数func2

    func2(action) // ok

}

内联函数引的非局部返回

局部返回

我们知道，一般函数调用的返回都是局部的，比如:

// 这里直接return，也就是返回到调用它的地方

fun tReturn() {

    return

}


fun func() {

    println("before")

    // 调用了toRetrun()

    tReturn()

    println("after")

}


// 测试

fun main() {

    func()

}

结果如下:

before

after

这是正常的，因为func()函数先打印before，然后调用tReturn()，tReturn()入栈，执行return，tReturn()出栈，回到func()函数，接着向下打印after。

但是，如果将func()声明为内联的，然后将tReturn()作为参数传入，那么func()方法体就变了，比如:

// func声明为内联的，然后传入action参数

inline fun func(action: () -> Unit) {

    println("before")

    action.invoke()

    println("after")

}


fun main() {

    // 参数跟tReturn一样

    func { return }

}

结果:

before

原理也很简单，因为参数action会被复制到func()函数中，也就合并为一个方法了，等价于:

inline fun func() {

    println("before")

    return // 这就是参数action的函数体，直接返回了

    println("after")

}

这个不难理解，那么，如果不加inline，只是修改参数为action可以吗，比如:

// 这里没有加inline 参数一样是action

fun func(action: () -> Unit) {

    println("before")

    action.invoke()

    println("after")

}


fun main() {

    func { return } // 报错

}

这会直接报错:

Kotlin: 'return' is not allowed here

这是不允许的，因为它不知道你要return到哪个地方，但是可以这样写:

fun main() {

    // return 添加了标记，标记为返回到func这个地方

    func { return@func }

}

结果:

before

after

综上，一句话: 普通函数参数的return都是局部返回的，而内联函数是全局返回的。

那么，怎么防备这种风险呢，或者说: 怎么让一个函数既可以内联，又不让它的参数有全局返回的return呢？比如:

inline fun func(action: () -> Unit) {

    println("before")

    action() // 希望这里不要有return，有就直接报错

    println("after")

}

使用crossinline即可！我们修改函数如下:

// 参数用crossinline修饰

inline fun func(crossinline action: () -> Unit) {

    println("before")

    action()

    println("after")

}


// 调用

fun main() {

    func { return } // 报错: Kotlin: 'return' is not allowed here

    func { return@func } // 正常

}

可以看到，corssinline在保证函数是内联的情况下，限制了全局返回

总结

• kotlin为了书写简洁，引入了lambda
• 但是lambda有性能开销
• 性能开销在java7优化了，但是kotlin兼容java6，无法享受这个优化
• 所以kotlin引入内联来解决这个问题
• 内联是在编译期将被调用的函数拷贝到调用方的函数体，从而避免创建内部类
• 使用inline可以将函数声明为内联的，内联函数参数是全局返回的
• 使用noinline可以修饰函数参数为不内联
• 使用crossinline可以修饰函数参数为内联，而且不能全局返回