Kotlin：安全的 lambdas（没有内存泄漏）？

Question

在阅读了this article about Memory Leaks 之后，我想知道在 Kotlin Android 项目中使用 lambdas 是否安全。确实，lambda 语法让我更轻松地编程，但是内存泄漏呢？

作为问题的一个例子，我从我的一个项目中获取了一段代码，我在其中构建了一个 AlertDialog。这段代码在我项目的 MainActivity 类中。

fun deleteItemOnConfirmation(id: Long) : Unit {
        val item = explorerAdapter.getItemAt(id.toInt())
        val stringId = if (item.isDirectory) R.string.about_to_delete_folder else R.string.about_to_delete_file

        val dialog = AlertDialog.Builder(this).
                setMessage(String.format(getString(stringId), item.name)).setPositiveButton(
                R.string.ok, {dialog: DialogInterface, id: Int ->
                        val success = if (item.isDirectory) ExplorerFileManager.deleteFolderRecursively(item.name)
                        else ExplorerFileManager.deleteFile(item.name)
                        if (success) {
                            explorerAdapter.deleteItem(item)
                            explorerRecyclerView.invalidate()
                        }
                        else Toast.makeText(this@MainActivity, R.string.file_deletion_error, Toast.LENGTH_SHORT).show()
                    }).setNegativeButton(
                R.string.cancel, {dialog: DialogInterface, id: Int ->
                    dialog.cancel()
        })

        dialog.show()
}

我的问题很简单：为正负按钮设置的两个 lambdas 会导致内存泄漏吗？ （我的意思是，kotlin lambdas 是否简单地转换为 Java 匿名函数？）

编辑：也许我已经得到了答案in this Jetbrains Topic。

Answer 1

编辑（2017 年 2 月 19 日）：我收到了 Mike Hearn 关于此问题的非常全面的reply：

与 Java 一样，Kotlin 中发生的事情因情况而异。

• 如果 lambda 被传递给一个内联函数并且没有标记为 noinline，那么整个事情都会沸腾并且没有额外的类或 对象已创建。
• 如果 lambda 没有捕获，那么它将作为一个单例类发出，其实例被一次又一次地重用（一个类+一个对象 分配）。
• 如果 lambda 捕获，则每次使用 lambda 时都会创建一个新对象。

因此，除了内联情况外，它与 Java 的行为相似 哪里更便宜。这种编码 lambda 的有效方法 是 Kotlin 中的函数式编程更具吸引力的原因之一 比在 Java 中。

---

编辑（2017 年 2 月 17 日）：我已在 Kotlin discussions 中发布了有关此主题的问题。也许 Kotlin 工程师会带来一些新的东西。

---

kotlin lambdas 是否简单地转换为 Java 匿名函数？

我自己也在问这个问题（这里有一个简单的更正：这些被称为 匿名类，而不是函数）。 Koltin 文档中没有明确的答案。他们只是state那个

使用高阶函数会带来一定的运行时惩罚：每个 函数是一个对象，它捕获一个闭包，即那些变量 在函数体中访问。

在函数体中访问的变量有点令人困惑。对封闭类实例的引用是否也计算在内？

我已经看到您在问题中引用的主题，但目前看来它已经过时了。我找到了更多最新信息here：

Lambda 表达式或匿名函数保留隐式引用 封闭类

因此，不幸的是，Kotlin 的 lambda 似乎与 Java 的匿名内部类存在相同的问题。

为什么匿名内部类不好？

来自Javaspecs：

类 O 的直接内部类 C 的实例 i 关联 有一个 O 的实例，称为 O 的直接封闭实例 一世。对象的直接封闭实例（如果有）是 在创建对象时确定

这意味着匿名类将始终具有对封闭类实例的隐式引用。而且由于引用是隐式的，因此无法摆脱它。

看一个简单的例子

public class YourActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new Thread(new Runnable() {
                 // the inner class will keep the implicit reference to the outer activity
                @Override
                public void run() {
                 // long-running task
                }
        }).start();
   }
}

如您所见，在这种情况下，在执行长时间运行的任务之前会出现内存泄漏。一种解决方法是使用静态嵌套类。

由于Kotlin's 非内联 lambda 持有对封闭类实例的引用，因此它们在内存泄漏方面存在类似问题。

奖励：与其他 Lambda 实现的快速比较

Java 8 Lambda

语法：

• 声明SAM（单一抽象方法）接口

  interface Runnable { void run(); }
  

• 将此接口用作 lambda 的类型

  public void canTakeLambda(Runnable r) { ... }
  

• 传递你的 lambda

  canTakeLambda(() -> System.out.println("Do work in lambda..."));
  

内存泄漏问题： 如specs 所述：

对此的引用——包括通过 不合格的字段引用或方法调用——是， 本质上，是对最终局部变量的引用。 Lambda 机构 包含此类引用捕获此的适当实例。 在 在其他情况下，对象不会保留对 this 的引用。

简单地说，如果您不使用封闭类中的任何字段/方法，则不会像匿名类那样隐式引用this。

Retrolambda

来自docs

Lambda 表达式通过将它们转换为匿名来反向移植 内部类。这包括使用单例的优化 无状态 lambda 表达式的实例，以避免重复对象 分配。

我猜，这是不言自明的。

苹果的 Swift

语法：

• 声明类似于 Kotlin，在 Swift 中 lambda 被称为闭包：

  func someFunctionThatTakesAClosure(closure: (String) -> Void) {}
  

• 通过闭包

  someFunctionThatTakesAClosure { print($0) }
  

  这里，$0 指的是闭包的第一个 String 参数。这对应于 Kotlin 中的 it。注意：与 Kotlin 不同，在 Swift 中我们还可以引用其他参数，例如 $1、$2 等。

内存泄漏问题：

在 Swift 中，就像在 Java 8 中一样，闭包仅在访问实例的属性（例如 self.someProperty）或如果闭包调用实例上的方法，例如self.someMethod()。

开发人员还可以轻松地指定他们只想捕获弱引用：

   someFunctionThatTakesAClosure { [weak self] in print($0) }

我希望在 Kotlin 中也有可能：)

Answer 2

当某些由于不再需要而应该被删除的对象不能被删除时，就会发生内存泄漏，因为具有较长生命周期的对象引用了该对象。最简单的示例是将Activity 的引用存储在static 变量中（我是从Java 角度说的，但在Kotlin 中类似）：在用户单击“返回”按钮后，Activity 是不再需要，但它仍会保存在内存中 - 因为一些静态变量仍然指向此活动。
现在，在您的示例中，您没有将您的 Activity 分配给某个 static 变量，没有涉及 Kotlin 的 objects 可以防止您的 Activity 被垃圾收集 - 您的代码中涉及的所有对象有大致相同的生命周期，这意味着不会有内存泄漏。

附：我已经刷新了我对 Kotlin 的 lambda 实现的记忆：在否定按钮单击处理程序的情况下，您没有引用外部范围，因此编译器将创建单击侦听器的单个实例，该实例将在所有单击中重用在这个按钮上。在肯定按钮单击侦听器的情况下，您引用的是外部范围 (this@MainActivity)，因此在这种情况下，Kotlin 将在您每次创建对话框时创建匿名类的新实例（并且此实例将具有对外部类的引用，MainActivity)，因此行为与您用 Java 编写此代码完全相同。

Answer 3

这是一个（潜在）泄漏的简单示例，其中闭包/块捕获this：

class SomeClass {
    fun doWork() {
        doWorkAsync { onResult() } // leaks, this.onResult() captures `this`
    }

    fun onResult() { /* some work */ }
}

您需要使用 Wea​​kReference。

fun doWork() {
    val weakThis = WeakReference(this)
    doWorkAsync { weakThis?.get()?.onResult() } // no capture, no leak!
}

如果 Kotlin 从 Swift 复制 [weak self] 语法糖的想法，那就太好了。