深入理解.NET内存回收机制

转载自：http://www.chinamacro.com/blog/visit_detail.aspx?blogid=177
.Net平台提供了许多新功能，这些功能能够帮助程序员生产出更高效和稳定的代码。其中之一就是垃圾回收器（GC）。这篇文章将深入探讨这一功能，了解它是如何工作的以及如何编写代码来更好地使用这一.Net平台提供的功能。

.Net中的内存回收机制

垃圾回收器是用来管理应用程序的内存分配和释放的。在垃圾回收器出现以前，程序员在使用内存时需要向系统申请内存空间。有些语言，例如Visual Basic，可以自动完成向系统申请内存空间的工作。但是在诸如Visual C++的语言中要求程序员在程序代码中申请内存空间。如果程序员在使用了内存之后忘了释放内存，则会引起内存泄漏。但是有了垃圾回收器，程序员就不必关心内存中对象在离开生存期后是否被释放的问题。当一个应用程序在运行的时候，垃圾回收器设置了一个托管堆。托管堆和C语言中的堆向类似，但是程序员不需要从托管堆中释放对象，并且在托管堆中对象的存放是连续的。

每次当开发人员使用 new 运算符创建对象时，运行库都从托管堆为该对象分配内存。新创建的对象被放在上次创建的对象之后。垃圾回收器保存了一个指针，该指针总是指向托管堆中最后一个对象之后的内存空间。当新的对象被产生时，运行库就知道应该将新的对象放在内存的什么地方。同时开发人员应该将相同类型的对象放在一起。例如当开发人员希望向数据库写入数据的时侯，首先需要创建一个连接对象，然后是Command对象，最后是DataSet对象。如果这些对象放在托管堆相邻的区域内，存取它们就非常快。

当垃圾回收器的指针指向托管堆以外的内存空间时，就需要回收内存中的垃圾了。在这个过程中，垃圾回收器首先假设在托管堆中所有的对象都需要被回收。然后它在托管堆中寻找被根对象引用的对象（根对象就是全局，静态或处于活动中的局部变量以及寄存器指向的对象），找到后将它们加入一个有效对象的列表中，并在已经搜索过的对象中寻找是否有对象被新加入的有效对象引用。直到垃圾回收器检查完所有的对象后，就有一份根对象和根对象直接或间接引用了的对象的列表，而其它没有在表中的对象就被从内存中回收。

当对象被加入到托管堆中时，如果它实现了finalize（）方法，垃圾回收器会在它的终结列表（Finalization List）中加入一个指向该对象的指针。当该对象被回收时，垃圾回收器会检查终结列表，看是否需要调用对象的finalize（）方法。如果有的话，垃圾回收器将指向该对象的指针加入一个完成器队列中，该完成器队列保存了那些准备调用finalize（）方法的对象。到了这一步对象还不是真正的垃圾对象。因此垃圾回收器还没有把他们从托管堆中回收。

当对象准备被终结时，另一个垃圾回收器线程会调用在完成器队列中每个对象的finalize（）方法。当调用完成后，线程将指针从完成器队列中移出，这样垃圾回收器就知道在下一次回收对象时可以清除被终结的对象了。从上面可以看到垃圾回收机制带来的很大一部分额外工作就是调用finalize（）方法，因此在实际编程中开发人员应该避免在类中实现finalize（）方法。

对于finalize（）方法的另一个问题是开发人员不知道什么时候它将被调用。它不像C++中的析构函数在删除一个对象时被调用。为了解决这个问题，在.Net中提供了一个接口IDisposable。微软建议在实现带有fianlize（）方法的类的时侯按照下面的模式定义对象：


public class Class1 : IDisposable
{
public Class1()
{
}

~Class1 ()
{
//垃圾回收器将调用该方法，因此参数需要为false。
Dispose (false);
}

//该方法定义在IDisposable接口中。
public void Dispose ()
{
//该方法由程序调用，在调用该方法之后对象将被终结。
//因为我们不希望垃圾回收器再次终结对象，因此需要从终结列表中去除该对象。
GC.SuppressFinalize (this);
//因为是由程序调用该方法的，因此参数为true。
Dispose (true);
}

//所有与回收相关的工作都由该方法完成
private void Dispose(bool disposing)
{
lock(this) //避免产生线程错误。
{
if (disposing)
{
//需要程序员完成释放对象占用的资源。
}

//对象将被垃圾回收器终结。在这里添加其它和清除对象相关的代码。
}
}
}

现在我们了解了垃圾回收器工作的基本原理，接下来让我们看一看垃圾回收器内部是如何工作的。目前有很多种类型的垃圾回收器。微软实现了一种生存期垃圾回收器（Generational Garbage Collector）。生存期垃圾回收器将内存分为很多个托管堆，每一个托管堆对应一种生存期等级。生存期垃圾回收器遵循着下面的原则：

新生成的对象，其生存期越短；而对象生成时间越长的对象，其生存期也就越长。对于垃圾回收器来说，回收一部分对象总是比回收全部对象要快，因此垃圾回收器对于那些生存期短的对象回收的频率要比生存期长的对象的回收频率高。

.Net中的垃圾回收器中目前有三个生存期等级：0，1和2。0、1、2等级对应的托管堆的初始化大小分别是256K，2M和10M。垃圾回收器在发现改变大小能够提高性能的话，会改变托管堆的大小。例如当应用程序初始化了许多小的对象,并且这些对象会被很快回收的话，垃圾回收器就会将0等级的托管堆变为128K，并且提高回收的频率。如果情况相反，垃圾回收器发现在0等级的托管堆中不能回收很多空间时，就会增加托管堆的大小。
在应用程序初始化的之前，所有等级的托管堆都是空的。当对象被初始化的时候，他们会按照初始化的先后顺序被放入等级为0的托管堆中。在托管堆中对象的存放是连续的，这样使得托管堆存取对象的速度很快，因为托管对不必对内存进行搜索。垃圾回收器中保存了一个指针指向托管堆中最后一个对象之后的内存空间。图一中显示了一个包含四个对象的0等级的托管堆。


图一 包含四个对象的托管堆

当0等级托管堆被对象填满后，例如候程序初始化了新的对象，使0等级托管堆的大小超过了256K，垃圾回收器会检查托管堆中的所有对象，看是否有对象可以回收。当开始回收操作时，如前面提到的，垃圾回收器会找出根节点和根节点直接或间接引用了的对象，然后将这些对象转移到1等级托管堆中，并将0等级托管堆的指针移到最开始的位置以清除所有的对象。同时垃圾回收器会压缩1等级托管堆以保证所有对象之间没有内存空隙。当1等级托管堆满了之后，会将对象转移到2等级的托管堆。

例如在图一之后，垃圾回收器开始回收对象，假定D对象将被回收，同时程序创建了E和F对象。这时候托管堆中的对象如图二所示。


图二 回收对象后的0等级和1等级托管堆

然后程序创建了新的对象G和H，再一次触发了垃圾回收器。对象E将被回收。这时候托管堆中的对象如图三所示。



生存期垃圾回收器的原则也有例外的情况。当对象的大小超过84K时，对象会被放入"大对象区"。大对象区中的对象不会被垃圾回收器回收，也不会被压缩。这样做是为了强制垃圾回收器只能回收小对象以提高程序的性能。

控制垃圾回收器

在.Net框架中提供了很多方法使开发人员能够直接控制垃圾回收器的行为。通过使用GC.Collect（）或GC.Collect（int GenerationNumber）开发人员可以强制垃圾回收器对所有等级的托管堆进行回收操作。在大多数的情况下开发人员不需要干涉垃圾回收器的行为，但是有些情况下，例如当程序进行了非常复杂的操作后希望确认内存中的垃圾对象已经被回收，就可以使用上面的方法。另一个方法是GC.WaitForPendingFinalizers（），它可以挂起当前线程，直到处理完成器队列的线程清空该队列为止。

使用垃圾回收器最好的方法就是跟踪程序中定义的对象，在程序不需要它们的时候手动释放它们。例如程序中的一个对象中有一个字符串属性，该属性会占用一定的内存空间。当该属性不再被使用时，开发人员可以在程序中将其设定为null，这样垃圾回收器就可以回收该字符串占用的空间。另外，如果开发人员确定不再使用某个对象时，需要同时确定没有其它对象引用该对象，否则垃圾回收器不会回收该对象。

另外值得一提的是finalize（）方法应该在较短的时间内完成，这是因为垃圾回收器给finalize（）方法限定了一个时间，如果finalize（）方法在规定时间内还没有完成，垃圾回收器会终止运行finalize（）方法的线程。在下面这些情况下程序会调用对象的finalize（）方法：

0等级垃圾回收器已满

程序调用了执行垃圾回收的方法

公共语言运行库正在卸载一个应用程序域

公共语言运行库正在被卸载
（原文地址：http://www.yesky.com/20030311/1656401.shtml）

 

对.Net 垃圾回收Finalize 和Dispose的理解

我们先来谈谈析构函数。

析构函数是不可继承的。因此，除了自已所声明的析构函数外，一个类不具有其他析构函数。

由于析构函数要求不能带有参数，因此它不能被重载，所以一个类至多只能有一个析构函数。

析构函数是自动调用的，它不能被显式调用。当任何代码都不再可能使用一个实例时，该实例就符合被销毁的条件。此后，它所对应的实例析构函数随时均可能被调用。销毁一个实例时，按照从派生程度最大到派生程度最小的顺序，调用该实例的继承链中的各个析构函数。析构函数可以在任何线程上执行。

下列示例的输出

using System;
class A
{
~A() {
Console.WriteLine("A's destructor");
}
}
class B: A
{
~B() {
Console.WriteLine("B's destructor");
}
}
class Test
{
static void Main() {
B b = new B();
b = null;
GC.Collect();
GC.WaitForPendingFinalizers();
}
}

为

B's destructor
A's destructor

这是由于继承链中的析构函数是按照从派生程度最大到派生程度最小的顺序调用的。

析构函数实际上是重写了 System.Object 中的虚方法 Finalize。C# 程序中不允许重写此方法或直接调用它（或它的重写）。例如，下列程序

class A
{
override protected void Finalize() {}   // error
public void F() {
this.Finalize();                     // error
}
}

包含两个错误。

编译器的行为就像此方法和它的重写根本不存在一样。因此，以下程序：

class A
{
void Finalize() {}                     // permitted
}

是有效的，所声明的方法隐藏了 System.Object 的 Finalize 方法。


好，现在我们开始来谈谈Finalize 和Dispose。

Finalize 和Dispose(bool disposing)和 Dispose() 的相同点:

这三者都是为了释放非托管资源服务的.

Finalize 和 Dispose() 和Dispose(bool disposing)的不同点:

1. Finalize是CLR提供的一个机制, 它保证如果一个类实现了Finalize方法,那么当该类对象被垃圾回收时,垃圾回收器会调用Finalize方法.而该类的开发者就必须在Finalize方法中处理 非托管资源的释放. 但是什么时候会调用Finalize由垃圾回收器决定,该类对象的使用者(客户)无法控制.从而无法及时释放掉宝贵的非托管资源.由于非托管资源是比较宝贵了,所以这样会降低性能.
2. Dispose(bool disposing)不是CRL提供的一个机制, 而仅仅是一个设计模式(作为一个IDisposable接口的方法),它的目的是让供类对象的使用者(客户)在使用完类对象后,可以及时手动调用非托管资源的释放,无需等到该类对象被垃圾回收那个时间点.这样类的开发者就只需把原先写在Finalize的释放非托管资源的代码,移植到Dispose(bool disposing)中.  而在Finalize中只要简单的调用 "Dispose(false)"(为什么传递false后面解释)就可以了.

这个时候我们可能比较疑惑,为什么还需要一个Dispose()方法?难道只有一个Dispose(bool disposing)或者只有一个Dispose()不可以吗?
答案是: 
        只有一个Dispose()不可以. 为什么呢?因为如果只有一个Dispose()而没有Dispose(bool disposing)方法.那么在处理实现非托管资源释放的代码中无法判断该方法是客户调用的还是垃圾回收器通过Finalize调用的.无法实现判断如果是客户手动调用,那么就不希望垃圾回收器再调用Finalize()(调用GC.SupperFinalize方法).另一个可能的原因(:我们知道如果是垃圾回收器通过Finalize调用的,那么在释放代码中我们可能还会引用其他一些托管对象,而此时这些托管对象可能已经被垃圾回收了, 这样会导致无法预知的执行结果(千万不要在Finalize中引用其他的托管对象).

        所以确实需要一个bool disposing参数, 但是如果只有一个Dispose(bool disposing),那么对于客户来说,就有一个很滑稽要求,Dispose(false)已经被Finalize使用了,必须要求客户以Dispose(true)方式调用,但是谁又能保证客户不会以Dispose(false)方式调用呢?所以这里采用了一中设计模式:重载  把Dispose(bool disposing)实现为 protected, 而Dispose()实现为Public,那么这样就保证了客户只能调用Dispose()(内部调用Dispose(true)//说明是客户的直接调用),客户无法调用Dispose(bool disposing).

范例如下:

public class BaseResource: IDisposable
{
  //前面我们说了析构函数实际上是重写了 System.Object 中的虚方法 Finalize, 默认情况下,一个类是没有析构函数的,也就是说,对象被垃圾回收时不会被调用Finalize方法
  ~BaseResource()     
   {
      // 为了保持代码的可读性性和可维护性,千万不要在这里写释放非托管资源的代码
      // 必须以Dispose(false)方式调用,以false告诉Dispose(bool disposing)函数是从垃圾回收器在调用Finalize时调用的
      Dispose(false);
   }
  
  
   // 无法被客户直接调用
   // 如果 disposing 是 true, 那么这个方法是被客户直接调用的,那么托管的,和非托管的资源都可以释放
   // 如果 disposing 是 false, 那么函数是从垃圾回收器在调用Finalize时调用的,此时不应当引用其他托管对象所以,只能释放非托管资源
   protected virtual void Dispose(bool disposing)
   {
     
         // 那么这个方法是被客户直接调用的,那么托管的,和非托管的资源都可以释放
         if(disposing)
         {
            // 释放 托管资源
            OtherManagedObject.Dispose();
         }
        
        
         //释放非托管资源
         DoUnManagedObjectDispose();
        
                
         // 那么这个方法是被客户直接调用的,告诉垃圾回收器从Finalization队列中清除自己,从而阻止垃圾回收器调用Finalize方法.        
         if(disposing) 
           GC.SuppressFinalize(this);  
          
   } 
  
   //可以被客户直接调用
   public void Dispose()
   {
     //必须以Dispose(true)方式调用,以true告诉Dispose(bool disposing)函数是被客户直接调用的
      Dispose(true);     
   }
}

上面的范例达到的目的:

1/ 如果客户没有调用Dispose(),未能及时释放托管和非托管资源,那么在垃圾回收时,还有机会执行Finalize(),释放非托管资源,但是造成了非托管资源的未及时释放的空闲浪费

2/ 如果客户调用了Dispose(),就能及时释放了托管和非托管资源,那么该对象被垃圾回收时,不回执行Finalize(),提高了非托管资源的使用效率并提升了系统性能