C# 中释放内存的正确方法是什么

Question

我有一个 C# 定时器，它在它的方法中执行一些代码。在代码中我使用了几个临时对象。

1. 如果我在方法内有类似 Foo o = new Foo(); 的内容，是否意味着每次计时器计时时，我都会创建一个新对象和对该对象的新引用对象？

2. 如果我有 string foo = null 然后我只是在 foo 中放入一些临时内容，它与上面相同吗？

3. 垃圾收集器是否删除了该对象，并且引用或对象不断创建并保留在内存中？

4. 如果我只是声明 Foo o; 并且不将其指向任何实例，那么方法结束时不是会被释放吗？

5. 如果我想确保删除所有内容，最好的方法是什么：

   • 在方法内使用 using 语句
   • 最后调用 dispose 方法
   • 将 Foo o; 放在计时器的方法之外，并在内部进行赋值 o = new Foo()，这样在计时器的方法之后，指向该对象的指针就会被删除方法结束，垃圾收集器将删除该对象。

Answer 1

1.如果我有类似 Foo o = new Foo(); 的东西在方法内部，这样做
意味着每次计时器滴答作响时，
我正在创建一个新对象和一个新对象
引用该对象？

是的。

2.如果我有字符串 foo = null 然后我只是在 foo 中放入一些临时的东西，
和上面一样吗？

如果您问行为是否相同，那么是的。

3.垃圾收集器是否删除过对象和引用？
对象不断被创建并且
留在记忆中吗？

在引用被视为未使用后，这些对象使用的内存肯定会被收集。

4.如果我只是声明 Foo o;并且不将其指向任何实例，不是吗
方法结束时处理？

不，因为没有创建对象，所以没有要收集的对象（“处置”不是正确的词）。

5.如果我想确保所有内容都被删除，最好的方法是什么
做起来

了IDisposable，那么您肯定希望尽快贪婪地调用Dispose。 using 关键字使这变得更容易，因为它以异常安全的方式自动调用 Dispose。

除此之外，除了停止使用该对象之外，您实际上不需要做任何其他事情。如果引用是局部变量，那么当它超出范围时，它将有资格被收集。¹如果它是类级别变量，那么您可能需要分配 null使其在包含类符合资格之前使其符合资格。

---

¹这在技术上是不正确的（或者至少有点误导）。对象在超出范围之前就可以进行收集。 CLR 经过优化，可以在检测到不再使用引用时收集内存。在极端情况下，即使对象的方法之一仍在执行，CLR 也可以收集对象！

更新：

下面的示例演示了 GC 将收集对象，即使它们可能仍在范围内。您必须编译发布版本并在调试器之外运行它。

static void Main(string[] args)
{
    Console.WriteLine("Before allocation");
    var bo = new BigObject();
    Console.WriteLine("After allocation");
    bo.SomeMethod();
    Console.ReadLine();
    // The object is technically in-scope here which means it must still be rooted.
}

private class BigObject
{
    private byte[] LotsOfMemory = new byte[Int32.MaxValue / 4];

    public BigObject()
    {
        Console.WriteLine("BigObject()");
    }

    ~BigObject()
    {
        Console.WriteLine("~BigObject()");
    }

    public void SomeMethod()
    {
        Console.WriteLine("Begin SomeMethod");
        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.WriteLine("End SomeMethod");
    }
}

在我的机器上，终结器在 SomeMethod 仍在执行时运行！

Answer 2

.NET 垃圾收集器会为您处理这一切。

它能够确定对象何时不再被引用，并将（最终）释放已分配给它们的内存。

Answer 3

一旦对象超出范围变得无法访问，就可以进行垃圾回收（谢谢ben！）。除非垃圾收集器认为您的内存不足，否则不会释放内存。

对于托管资源，垃圾收集器会知道这是什么时候，并且您不需要执行任何操作。

对于非托管资源（例如与数据库的连接或打开的文件），垃圾收集器无法知道它们消耗了多少内存，这就是为什么您需要手动释放它们（使用 dispose，或者更好的是 using 块）

如果对象没有被释放，要么你有足够的内存剩余并且没有必要，要么你在应用程序中维护对它们的引用，因此垃圾收集器不会释放它们（如果你实际上使用这个引用你维持）

Answer 4

让我们一一回答您的问题。

1. 是的，每当执行此语句时，您都会创建一个新对象，但是，当您退出该方法时，它会“超出范围”并且有资格进行垃圾回收。
2. 嗯，这与 #1 相同，只是您使用了字符串类型。字符串类型是不可变的，每次赋值时都会得到一个新对象。
3. 是的，垃圾收集器会收集超出范围的对象，除非您将对象分配给具有大范围的变量（例如类变量）。
4. 是的。
5. using 语句仅适用于实现 IDisposable 接口的对象。如果是这种情况，那么对于方法范围内的对象来说，使用是最好的。除非有充分的理由，否则不要将 Foo o 放在更大的范围内。最好将任何变量的范围限制在有意义的最小范围内。

Answer 5

以下是一个快速概述：

• 一旦引用消失，您的对象将可能被垃圾收集。
• 如果所有对垃圾的引用确实消失了，您只能依靠统计收集来保持堆大小正常。换句话说，无法保证特定对象将被垃圾收集。
  • 因此，您的终结器也永远不会被保证被调用。避免终结器。
• 两种常见的泄漏源：
  • 事件处理程序和委托是引用。如果您订阅某个对象的事件，则您正在引用该对象。如果您有一个对象方法的委托，那么您就是在引用它。
  • 根据定义，非托管资源不会自动收集。这就是 IDisposable 模式的用途。
• 最后，如果您想要一个不会阻止对象被收集的引用，请查看 WeakReference。

最后一件事：如果您声明 Foo foo; 而不分配它，您不必担心 - 不会泄漏任何内容。如果 Foo 是引用类型，则不会创建任何内容。如果 Foo 是值类型，它会在堆栈上分配，因此会自动清理。

Answer 6

1. 是的，
2. 你说的“相同”是什么意思？每次运行该方法时都会重新执行该方法。
3. 是的，.Net 垃圾收集器使用一种算法，该算法从任何全局/范围内变量开始，在递归地跟踪找到的任何引用的同时遍历它们，并删除内存中被视为无法访问的任何对象。 请参阅此处了解有关垃圾收集的更多详细信息
4. 是的，当方法退出时，方法中声明的所有变量的内存都会被释放，因为它们都是不可访问的。此外，任何已声明但从未使用的变量都将被编译器优化，因此实际上您的 Foo 变量永远不会占用内存。
5. using 语句只是在退出时调用 IDisposable 对象的 dispose，因此这相当于您的第二个要点。两者都会表明您已完成该对象，并告诉 GC 您已准备好放弃它。覆盖对该对象的唯一引用也会产生类似的效果。

Answer 7

垃圾收集器将会出现并清理任何不再引用它的东西。除非您在 Foo 中有非托管资源，否则调用 Dispose 或对其使用 using 语句并不会真正帮助您。

我相当确定这适用，因为它仍然是 C# 中的。但是，我使用 XNA 参加了游戏设计课程，我们花了一些时间讨论 C# 的垃圾收集器。垃圾收集的成本很高，因为您必须检查是否有任何对要收集的对象的引用。因此，GC 会尝试尽可能推迟此操作。因此，只要当程序达到 700MB 时物理内存没有耗尽，就可能只是 GC 比较懒，还没有关心它。

但是，如果您只是在循环外使用 Foo o 并每次都创建一个 o = new Foo()，那么一切都应该正常。

Answer 8

正如 Brian 指出的，GC 可以收集任何无法访问的内容，包括仍在范围内的对象，甚至在这些对象的实例方法仍在执行时。考虑以下代码：

class foo
{
    static int liveFooInstances;

    public foo()
    {
        Interlocked.Increment(ref foo.liveFooInstances);
    }

    public void TestMethod()
    {
        Console.WriteLine("entering method");
        while (Interlocked.CompareExchange(ref foo.liveFooInstances, 1, 1) == 1)
        {
            Console.WriteLine("running GC.Collect");
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
        Console.WriteLine("exiting method");
    }

    ~foo()
    {
        Console.WriteLine("in ~foo");
        Interlocked.Decrement(ref foo.liveFooInstances);
    }

}

class Program
{

    static void Main(string[] args)
    {
        foo aFoo = new foo();
        aFoo.TestMethod();
        //Console.WriteLine(aFoo.ToString()); // if this line is uncommented TestMethod will never return
    }
}

如果使用调试构建、附加调试器或使用未注释的指定行运行，则 TestMethod 将永远不会返回。但是在没有附加调试器的情况下运行 TestMethod 将返回。