我知道内联函数可能会提高性能并导致生成的代码增长，但我不确定何时使用它是正确的。

lock(l) { foo() }

Instead of creating a function object for the parameter and generating a call, the compiler could emit the following code. (Source)

l.lock()
try {
  foo()
}
finally {
  l.unlock()
}

但是我发现 kotlin 没有为非内联函数创建函数对象。为什么？

/**non-inline function**/
fun lock(lock: Lock, block: () -> Unit) {
    lock.lock();
    try {
        block();
    } finally {
        lock.unlock();
    }
}

最佳答案

假设您创建了一个接受 () -> Unit 类型的 lambda(无参数，无返回值)的高阶函数，并像这样执行它:

fun nonInlined(block: () -> Unit) {
    println("before")
    block()
    println("after")
}

用 Java 的说法，这将转化为类似这样的东西(简化!):

public void nonInlined(Function block) {
    System.out.println("before");
    block.invoke();
    System.out.println("after");
}

当你从 Kotlin 调用它时......

nonInlined {
    println("do something here")
}

在底层，将在此处创建 Function 的实例，将代码包装在 lambda 中(同样，这是简化的):

nonInlined(new Function() {
    @Override
    public void invoke() {
        System.out.println("do something here");
    }
});

所以基本上，调用这个函数并将 lambda 传递给它总是会创建一个 Function 对象的实例。

另一方面，如果你使用 inline 关键字:

inline fun inlined(block: () -> Unit) {
    println("before")
    block()
    println("after")
}

当你这样调用它时:

inlined {
    println("do something here")
}

不会创建 Function 实例，而是将内联函数内围绕 block 调用的代码复制到调用站点，因此您将获得字节码中的类似内容:

System.out.println("before");
System.out.println("do something here");
System.out.println("after");

在这种情况下，不会创建新实例。

https://stackoverflow.com/questions/44471284/