返回列表
发布日期: 2009-02-24 17:28 发布者: cobra Bookmark and Share 原版编程图书超低价热卖 1#
t T
赞助商
背景

这两天帮助其它项目组Review代码,发现有些地方实现了IDispose接口,同时也发现了一些关于IDispose的问题:

1.A类型实现了IDispose接口,B类型里面含有A类型的字段,B类型没有实现IDispose接口

2.一个类里面实现了Finalize终结器,同时也实现了IDispose接口,但在Dispose方法里面没有调用GC.SuppressFinalize(this)方法.

下面我对以上两个问题分别分析一下,并提出解决方案.

问题1:如果A类型里面有非托管资源需要在实现的IDispose接口里面释放,由于B类型没有实现IDispose接口,B类型的使用者要想释放A类型的非托管资源并不方便.这样的话,就有可能忘记了释放A类型的非托管资源.

解决方案:

实现B类型的IDispose接口,在Dispose方法里面调用A类型的Dispose方法.这样,B类型的使用者在调用B类型Dispose的同时,就把A类型的Dispose也调用了.

问题2:在Dispose方法里面没有调用GC.SuppressFinalize(this)方法,会有什么问题呢,这样会导致垃圾回收器不能对这个类型的对象及时回收. 当GC开始工作的时候，它首先将没有终结器的垃圾对象从内存中移除，有终结器的所有对象则添加到一个垃圾队列当中。GC会调用一个新线程来执行这些对象的终结器。当终结器执行完毕后，这个对象会从队列中被移除。这个对象在队列中移除之后,当GC再次开始工作的时候,这个对象才能够被回收,所以有终结器的对象会比没有的在内存中保留更长的时间。在后面我会对这里再详细的描述一下.

解决方案:

在Dispose方法中调用GC.SuppressFinalize(this)方法.这样的话,就不会把有终结器的对象则添加到垃圾队列当中.

切入正题

.net中,非托管代码清理有两种方式:Finalize方式和Dispose方式.

Finalize方式:通过对自定义类型实现一个Finalize方法来释放非通过资源.

从.net2.0开始,C#编译器不能对Finalize进行显示的调用和重写,必须使用析构函数来实现它.
  1. class A
  2. {
  3.       ~A()
  4. {
  5.       释放资源;
  6. }
  7. }
复制代码
上面的代码就是通过Finalize方式来释放资源的跟C++用析构函数释放资源的代码很象.

但是它实现方式和C++不同,因为它是由垃圾回收器来管理内存的.

大家看到了,用Finalize方式释放非托管资源很简单,但是如果你了解了他的实现方式,你可能就不会选择用它来释放非托管资源.

那Finalize方式在.net内部是如何实现的呢?

当GC(垃圾回收器)开始工作的时候，它首先将没有终结器的垃圾对象从内存中移除，有终结器的所有对象则添加到一个终止化队列当中。GC会调用一个新线程来执行这些对象的终结器。当终结器执行完毕后，这些对象会从队列中被移除。这时候由于这些对象在第一次检测到的时候没有被释放,它们将会进入第1代对象,直到GC检测到第0代对象和第1代对象再次充满时,这时候GC才会把刚才那些对象释放掉,所以有终结器的对象会比没有的在内存中保留更长的时间。

提示:垃圾回收器把托管堆中的对象分为3代,分别是0,1,2.一般分配为:0代约256K,1代约是2MB,第2代约是MB,代龄越高,容量就越大,显然效率也就越低.首先被添加到托管堆中的对象被定为第0代,当第0代充满时,就会执行垃圾回收,未被回收的对象代领将提升1代.

由于以上原因应该避免仅使用Finalize方式释放非托管资源.

Dispose模式:在自定义类中实现IDispose接口,在接口中的Dispose方法中对非托管资源进行释放.闲话少说,上代码
  1. public class MyResourceRelease: IDisposable
  2.         {
  3.                     /// <summary>
  4.                     /// 保证资源只用释放一次
  5.                     /// </summary>
  6.             private bool _alreadyDisposed = false;

  8.             /// <summary>
  9.                     ///
  10.                     /// </summary>
  11.                     /// <param name="isDisposing">用来判断释放资源的类别(托管和非托管)</param>
  12.             protected virtual void Dispose(bool isDisposing)
  13.             {
  14.                 if(_alreadyDisposed)
  15.                 {
  16.                     return;
  17.                 }
  18.                 if(isDisposing)
  19.                 {
  20.                     //释放托管资源
  21.                 }
  22.                 //释放非托管资源
  23.                 _alreadyDisposed = true;
  24.             }

  26.             public void Dispose()
  27.             {
  28.                 Dispose(true);
  29.             }
  30.         }
复制代码
上面的代码就是用Dispose方式释放资源的方法.因为上面自定义的Dispose(bool isDisposing)方法是virtual的,所以还可以在派生类里面对它进行override
  1. public class MyDerivedResource: MyResourceRelease
  2.         {
  3.             private bool _disposed = false;

  5.             protected override void Dispose(bool isDisposing)
  6.             {
  7.                 if(_disposed)
  8.                 {
  9.                     return;
  10.                 }
  11.                             try
  12.                             {   
  13.                                   if(isDisposing)
  14.                                   {
  15.                                           //释放托管资源
  16.                                   }
  17.                                   //释放非托管资源
  18.                                 _disposed = true;
  19.                             }
  20.                             finally
  21.                             {
  22.                       base.Dispose(isDisposing);
  23.                             }

  25.             }
  26.         }
复制代码
这样可以确保释放继承链上所有对象的引用资源,在整个继承层次中传播Dispose模式.

思考

那用Dispose方式非托管资源就是最好的方法了吗?

其实不然,因为类型实现了IDispose接口,这个类的使用者必须显示调用Dispose方法,或者在创建该类型对象的时候使用using关键字,对于一些粗心的使用者可能会忘记调用Dispose方法,或者没有使用using关键字,这样就导致了非托管资源没有释放的后果.

最佳方案

同时实现终结器和Dispose方式.这样对于细心的使用者直接显示调用Dispose方法会提高垃圾回收的性能,对于粗心的使用者虽然忘记了调用Dispose方法,但也不至于使得非托管资源得不到释放.

注意这里用到了GC. SuppressFinalize(this)方法.

代码如下:
  1. public class MyResourceRelease: IDisposable
  2.         {
  3.                     ~MyResourceRelease()
  4.                     {
  5.                             Dispose(false);
  6.                     }
  7.                     /// <summary>
  8.                     /// 保证资源只用释放一次
  9.                     /// </summary>
  10.             private bool _alreadyDisposed = false;

  12.             /// <summary>
  13.                     ///
  14.                     /// </summary>
  15.                     /// <param name="isDisposing">用来判断释放资源的类别(托管和非托管)</param>
  16.             protected virtual void Dispose(bool isDisposing)
  17.             {
  18.                 if(_alreadyDisposed)
  19.                 {
  20.                     return;
  21.                 }
  22.               if(isDisposing)
  23.                 {
  24.                     //释放托管资源
  25.                 }
  26.                 //释放非托管资源
  27.                 _alreadyDisposed = true;
  28.             }

  30.             public void Dispose()
  31.             {
  32.                 Dispose(true);
  33.                             //阻止GC把该对象放入终结器队列
  34.                 GC.SuppressFinalize(this);
  35.             }
  36.         }
复制代码
文/我的地盘我做主  出处/博客园
赞助商
赞助商
TOP
返回列表