注册

内联函数产生原因和原理

为什么要内联函数

  • 因为: 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可以修饰函数参数为内联,而且不能全局返回


作者:奔波儿灞取经
链接:https://juejin.cn/post/7008422441026322462
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

0 个评论

要回复文章请先登录注册