实现安全关闭是否需要垃圾收集？

我最近参加了有关编程语言的在线课程，其中介绍了闭包。我写下了两个受本课程启发的示例，以便在提出问题之前提供一些背景信息。

第一个示例是一个SML函数，该函数生成从1到x的数字列表，其中x是该函数的参数：

fun countup_from1 (x: int) =
    let
        fun count (from: int) =
            if from = x
            then from :: []
            else from :: count (from + 1)
    in
        count 1
    end

在SML REPL中：

val countup_from1 = fn : int -> int list
- countup_from1 5;
val it = [1,2,3,4,5] : int list

该countup_from1函数使用帮助程序闭包count，该闭包x从其上下文捕获并使用变量。

在第二个示例中，当我调用一个函数时create_multiplier t，我得到了一个将其参数乘以t的函数（实际上是一个闭包）：

fun create_multiplier t = fn x => x * t

在SML REPL中：

- fun create_multiplier t = fn x => x * t;
val create_multiplier = fn : int -> int -> int
- val m = create_multiplier 10;
val m = fn : int -> int
- m 4;
val it = 40 : int
- m 2;
val it = 20 : int

因此，变量m绑定到函数调用返回的闭包上，现在我可以随意使用它了。

现在，为了使闭包在其整个生命周期内正常工作，我们需要延长捕获变量的生命周期t（在示例中，它是整数，但可以是任何类型的值）。据我所知，在SML中，这可以通过垃圾回收来实现：闭包保留对捕获值的引用，该值随后在销毁闭包时由垃圾回收器处理。

我的问题：总的来说，垃圾回收是确保关闭安全（在整个生命周期中都可以调用）的唯一可能机制吗？

还是有什么其他机制可以确保不进行垃圾收集而关闭的有效性：复制捕获的值并将其存储在关闭中？限制闭包本身的生存期，以便在其捕获的变量到期后不能调用它？

最受欢迎的方法是什么？

编辑

我不认为可以通过将捕获的变量复制到闭包中来解释/实现上述示例。通常，捕获的变量可以是任何类型，例如，它们可以绑定到非常大的（不可变的）列表。因此，在实现中，复制这些值将非常低效。

为了完整起见，这是另一个使用引用（和副作用）的示例：

(* Returns a closure containing a counter that is initialized
   to 0 and is incremented by 1 each time the closure is invoked. *)
fun create_counter () =
    let
        (* Create a reference to an integer: allocate the integer
           and let the variable c point to it. *)
        val c = ref 0
    in
        fn () => (c := !c + 1; !c)
    end

(* Create a closure that contains c and increments the value
   referenced by it it each time it is called. *)
val m = create_counter ();

在SML REPL中：

val create_counter = fn : unit -> unit -> int
val m = fn : unit -> int
- m ();
val it = 1 : int
- m ();
val it = 2 : int
- m ();
val it = 3 : int

因此，变量也可以通过引用捕获，并且在创建变量的函数调用（create_counter ()）完成后仍然有效。

Rust编程语言在这方面很有趣。

Rust是一种系统语言，带有一个可选的GC，从一开始就以闭包进行设计。

作为其他变量，防锈剂有多种口味。堆栈关闭（最常见的关闭）是一次性使用的。他们生活在栈上，可以引用任何东西。拥有的闭包拥有所捕获变量的所有权。我认为它们生活在所谓的“交换堆”上，这是一个全局堆。他们的寿命取决于谁拥有他们。托管闭包存在于任务本地堆上，并由任务的GC进行跟踪。不过，我不确定它们的捕获限制。

不幸的是，从GC开始会使您成为XY综合征的受害者：

• 闭包需要的时间要长于闭包生存的时间（出于安全原因）
• 使用GC，我们可以将这些变量的寿命延长足够长的时间
• XY综合征：还有其他延长寿命的机制吗？

但是请注意，对于闭包而言，不需要延长变量的生存期。它只是由GC带来的；原来的安全声明只是被关闭的变量应与关闭时间一样长（即使那是不稳定的，我们可以说它们应一直存在到最后一次调用关闭之后）。

从本质上讲，我可以看到两种方法（并且有可能将它们组合在一起）：

1. 延长封闭变量的生命周期（例如，像GC一样）
2. 限制封盖的使用寿命

后者只是一种对称方法。它不经常使用，但是如果像Rust一样，您拥有一个可识别区域的类型系统，那么肯定有可能。

当通过值捕获变量时，不需要垃圾收集来安全关闭。一个突出的例子是C ++。C ++没有标准的垃圾回收。C ++ 11中的Lambda是闭包（它们从周围的范围捕获局部变量）。可以将lambda捕获的每个变量指定为通过值或通过引用捕获。如果是通过引用捕获的，则可以说它是不安全的。但是，如果按值捕获变量，那么它是安全的，因为捕获的副本和原始变量是分开的，并且具有独立的生存期。

在您提供的SML示例中，很容易解释：变量是按值捕获的。无需“延长任何变量的寿命”，因为您可以将其值复制到闭包中。这是可能的，因为在ML中无法将变量分配给它。因此，一个副本和许多独立副本之间没有区别。尽管SML具有垃圾回收功能，但它与闭包捕获变量无关。

通过引用（种类）捕获变量时，也不需要垃圾收集来安全关闭。一个示例是对C，C ++，Objective-C和Objective-C ++语言的Apple Blocks扩展。在C和C ++中没有标准的垃圾回收。默认情况下，块按值捕获变量。但是，如果使用声明了局部变量__block，则块看似“通过引用”捕获了它们，并且它们是安全的-即使在定义块的范围之后也可以使用它们。这里发生的是，__block变量实际上是一个下方的特殊结构，并且在复制块时（必须复制块才能首先在范围之外使用它们），它们会“移动”用于__block 我相信通过引用计数，变量可以进入堆，并且块可以管理其内存。

垃圾收集对于实现关闭不是必需的。在2008年，未进行垃圾收集的Delphi语言增加了闭包的实现。它是这样的：

编译器在幕后创建一个函子对象，该对象实现了一个表示闭包的接口。所有封闭的局部变量都从封闭过程的局部变量更改为函子对象上的字段。这样可以确保状态保持与函子一样长的时间。

此系统的局限性是函子无法捕获通过引用传递给封闭函数的任何参数以及函数的结果值，因为它们不是局部对象，其范围仅限于封闭函数的范围。

函子由闭包引用引用，它使用语法糖使它看起来像函数指针（而不是接口）一样指向开发人员。它为接口使用Delphi的引用计数系统，以确保函子对象（及其所持有的所有状态）只要需要就保持“活动”状态，然后在引用计数降至0时释放。