C#的GC，也就是垃圾回收机制 及其他

今天来谈谈C# 的GC ，也就是垃圾回收机制，非常的受教，总结如下

首先：谈谈托管，什么叫托管，我的理解就是托付C# 运行环境帮我们去管理，在这个运行环境中可以帮助我们开辟内存和释放内存，开辟内存一般用new ，内存是随机分配的，释放主要靠的是GC 也就是垃圾回收机制。哪么有两个大问题1.GC 可以回收任何对象吗？2.GC 什么时候来回收对象？回收那些对象？

对于第一个问题，GC 可以回收任何对象吗？我是这样理解的，首先要明白一点，C# 在强大也管不到非托管代码？哪么什么是非托管代码呢？比如stream （文件），connection （数据库连接），COM （组件）等等。。哪么这些对象是需要进行连接的，比如说我们写这样一句话FileStream fs = new FileStream(“d://a.txt”,FileMode.Open); 实际上已经创建了和d://a.txt 的连接，如果重复两次就会报错。哪么fs 这个对象叫做非托管对象，也就是说C#

不能自动去释放和d://a.txt 的连接。哪么对于非托管的代码怎么办，一会我来说。

    对于第二个问题，GC 什么时候来回收，回收什么对象？我想后面的就不用我说了，当然是回收托管对象了。但是GC 什么时候回收？是这样的：GC 是随机的，没有人知道他什么时候来，哪么我写了一个例子，证明这一点

private void button1_Click(object sender, EventArgs e)

{           

AA a = newAA ();

AA b = newAA ();

AA c = newAA ();

AA d = newAA ();

 

}

public class AA{}

在讲这个例子之前，要明白什么被称之为垃圾，垃圾就是一个内存区域，没有被任何引用指向，或者不再会被用到。哪么在第一次点击按钮的时候会生成4 个对象，第二次点击按钮的时候也会生成4 个对象，但是第一次生成的4 个对象就已经是垃圾了，因为，第一次生成的4 个对象随着 button1_Click 函数的结束而不会再被调用（或者说不能再被调用），哪么这个时候GC 就会来回收吗？不是的！我说了GC 是随机的，哪么你只管点你的，不一会GC 就会来回收的（这里我们可以认为，内存中存在一定数量的垃圾之后，GC 会来），要证明GC 来过我们把AA 类改成

public class AA

{

~AA()

{

        MessageBox .Show("析构函数被执行了" );

}

}

要明白，GC 清理垃圾，实际上是调用析构函数，但是这些代码是托管代码（因为里面没有涉及到Steam ，Connection 等。。）所以在析构函数中，我们可以只写一个MsgBox 来证明刚的想法；这个时候，运行你的程序，一直点击按钮，不一会就会出现一大堆的“析构函数被执行了”…

 

    好了，然后让我们看看能不能改变GC 这种为所欲为的天性，答案是可以的，我们可以通过调用GC.Collect(); 来强制GC 进行垃圾回收，哪么button1_Click 修改如下

private void button1_Click(object sender, EventArgs e)

{           

AA a = newAA ();

AA b = newAA ();

AA c = newAA ();

AA d = newAA ();

GC .Collect();

}

哪么在点击第一次按钮的时候，生成四个对象，然后强制垃圾回收，这个时候，会回收吗？当然不会，因为，这四个对象还在执行中（方法还没结束），当点第二次按钮的时候，会出现四次"析构函数被执行了" ， 这是在释放第一次点击按钮的四个对象，然后以后每次点击都会出现四次"析构函数被执行了" ，哪么最后一次的对象什么时候释放的，在关闭程序的时候释放（因为关闭程序要释放所有的内存）。

 

好了，现在来谈谈非托管代码，刚才说过，非托管代码不能由垃圾回收释放，我们把AA 类改成如下

public classAA

{

     FileStream fs = new FileStream ("D://a.txt" ,FileMode .Open);

     ~AA()

     {

            MessageBox .Show("析构函数被执行了" );

  }

}

private void button1_Click(object sender, EventArgs e)

{

            AA a = newAA ();

}

如果是这样一种情况，哪么第二次点击的时候就会报错，原因是一个文件只能创建一个连接。哪么一定要释放掉第一个资源，才可以进行第二次的连接。哪么首先我们想到用GC .Collect() ，来强制释放闲置的资源，修改代码如下：

private void button1_Click(object sender, EventArgs e)

{

            GC .Collect();

            AA a = newAA ();

}

哪么可以看到，第二次点按钮的时候，确实出现了“析构函数被执行了“， 但是程序仍然错了，原因前面我说过，因为Stream 不是托管代码，所以C# 不能帮我们回收，哪怎么办？

自己写一个Dispose 方法；去释放我们的内存。代码如下：

public classAA :IDisposable

    {

        FileStream fs = new FileStream ("D://a.txt" ,FileMode .Open);

        ~AA()

        {

            MessageBox .Show("析构函数被执行了" );

 

        }

 

        #region IDisposable 成员

 

        public void Dispose()

        {

            fs.Dispose();

            MessageBox .Show("dispose执行了" );

        }

 

        #endregion

    }

好了，我们看到了，继承 IDisposable 接口以后会有一个Dispose 方法（当然了，你不想继承也可以，但是接口给我们提供一种规则，你不愿意遵守这个规则，就永远无法融入整个团队，你的代码只有你一个人能看懂），好了闲话不说，这样一来我们的 button1_Click 改为privatevoid button1_Click(object sender,EventArgs e)

{

            AA a = newAA ();

a.Dispose();

}

我们每次点击之后，都会发现执行了“ dispose 执行了”，在关闭程序的时候仍然执行了“析构函数被执行了”这意味了，GC 还是工作了，哪么如果程序改为：

private void button1_Click(object sender, EventArgs e)

{

            AA a = newAA ();

a.Dispose();

GC .Collect();

}

每次都既有“ dispose 执行了又有”“析构函数被执行了”，这意味着GC 又来捣乱了，哪么像这样包含Stream connection 的对象，就不用GC 来清理了，只需要我们加上最后一句话GC.SuppressFinalize(this)来告诉GC ，让它不用再调用对象的析构函数中。

抑制；阻止释放的意思。

那么改写后的AA 的dispose 方法如下：

SuppressFinalize说白了，就是这个及时结束了了，不要再调用其他的Dispose了。就是这个以上。通常在类型的Dispose进行好用。

 

        public void Dispose()

        {

            fs.Dispose();

            MessageBox .Show("dispose执行了" );

GC.SuppressFinalize(this);

        }

 

private void button1_Click(object sender, EventArgs e)

{
AA a = new AA ();
a = null;
GC .Collect();
}

 

这个额也是回收的好方法。a==null就是立即调用解构方法的简单表达。我认为。

 

转载地址：http://blog.csdn.net/xmsheji/article/details/5452914

扩展阅读：

http://lru52777.blog.163.com/blog/static/4247765520117169480377/

c#与c++的区别就包括托管代码和非托管代码。托管代码不允许进行对内存的操作，而是由固定的垃圾回收机制完成。关于什么是托管代码，什么是非托管的，我也不是很明白，还等高手来给解答。

 托管代码 (managed code)   由公共语言运行库环境（而不是直接由操作系统）执行的代码。托管代码应用程序可以获得公共语言运行库服务，例如自动垃圾回收、运行库类型检查和安全支持等。这些服务帮助提供独立于平台和语言的、统一的托管代码应用程序行为。
  Unmanaged Code - 非托管代码   在公共语言运行库环境的外部，由操作系统直接执行的代码。非托管代码必须提供自己的垃圾回收、类型检查、安全支持等服务；它与托管代码不同，后者从公共语言运行库中获得这些服务。例如COM/COM++组件,ActiveX控件,API函数,指针运算,自制的资源文件...这些的非托管的,其它就是托管的。
 感谢此段回答者：rock_solid

以上比较笼统，也是都知道的，例如流，文件啥的核心也是非托管的，.NET核心会自动实现的一个Dispose方法。，通常对于CLR来讲，非托管的。NET会为他提供一个Dispose方法，

扩展阅读二：

http://www.cnblogs.com/luminji/archive/2011/03/29/1997812.html

 

便于对文章的开展，需要先明确两个概念。

第一个就是很多人用.Net写程序，会谈到托管这个概念。那么.Net所指的资源托管到底是什么意思，是相对于所有资源，还是只限于某一方面资源？很多人对此不是很了解，其实.Net所指的托管只是针对内存这一个方面，并不是对于所有的资源；因此对于Stream，数据库的连接，GDI+的相关对象，还有Com对象等等，这些资源并不是受到.Net管理而统称为非托管资源。而对于内存的释放和回收，系统提供了GC-Garbage Collector，而至于其他资源则需要手动进行释放。

 

那么第二个概念就是什么是垃圾，通过我以前的文章，会了解到.Net类型分为两大类，一个就是值类型，另一个就是引用类型。前者是分配在栈上，并不需要GC回收；后者是分配在堆上，因此它的内存释放和回收需要通过GC来完成。GC的全称为“Garbage Collector”,顾名思义就是垃圾回收器，那么只有被称为垃圾的对象才能被GC回收。也就是说，一个引用类型对象所占用的内存需要被GC回收，需要先成为垃圾。那么.Net如何判定一个引用类型对象是垃圾呢，.Net的判断很简单，只要判定此对象或者其包含的子对象没有任何引用是有效的，那么系统就认为它是垃圾。

 

明确了这两个基本概念，接下来说说GC的运作方式以及其的功能。内存的释放和回收需要伴随着程序的运行，因此系统为GC安排了独立的线程。那么GC的工作大致是，查询内存中对象是否成为垃圾，然后对垃圾进行释放和回收。那么对于GC对于内存回收采取了一定的优先算法进行轮循回收内存资源。其次，对于内存中的垃圾分为两种，一种是需要调用对象的析构函数，另一种是不需要调用的。GC对于前者的回收需要通过两步完成，第一步是调用对象的析构函数，第二步是回收内存，但是要注意这两步不是在GC一次轮循完成，即需要两次轮循；相对于后者，则只是回收内存而已。

 

很明显得知，对于某个具体的资源，无法确切知道，对象析构函数什么时候被调用，以及GC什么时候会去释放和回收它所占用的内存。那么对于从C、C++之类语言转换过来的程序员来说，这里需要转变观念。

 

那么对于程序资源来说，我们应该做些什么，以及如何去做，才能使程序效率最高，同时占用资源能尽快的释放。前面也说了，资源分为两种，托管的内存资源，这是不需要我们操心的，系统已经为我们进行管理了；那么对于非托管的资源，这里再重申一下，就是Stream，数据库的连接，GDI+的相关对象，还有Com对象等等这些资源，需要我们手动去释放。

 

如何去释放，应该把这些操作放到哪里比较好呢。.Net提供了三种方法，也是最常见的三种，大致如下：

<!--[if !supportLists]-->1． <!--[endif]-->析构函数；

<!--[if !supportLists]-->2． <!--[endif]-->继承IDisposable接口，实现Dispose方法；

<!--[if !supportLists]-->3． <!--[endif]-->提供Close方法。

 

经过前面的介绍，可以知道析构函数只能被GC来调用的，那么无法确定它什么时候被调用，因此用它作为资源的释放并不是很合理，因为资源释放不及时；但是为了防止资源泄漏，毕竟它会被GC调用，因此析构函数可以作为一个补救方法。而Close与Dispose这两种方法的区别在于，调用完了对象的Close方法后，此对象有可能被重新进行使用；而Dispose方法来说，此对象所占有的资源需要被标记为无用了，也就是此对象被销毁了，不能再被使用。例如，常见SqlConnection这个类，当调用完Close方法后，可以通过Open重新打开数据库连接，当彻底不用这个对象了就可以调用Dispose方法来标记此对象无用，等待GC回收。明白了这两种方法的意思后，大家在往自己的类中添加的接口时候，不要歪曲了这两者意思。

 

接下来说说这三个函数的调用时机，我用几个试验结果来进行说明，可能会使大家的印象更深。

首先是这三种方法的实现，大致如下：

   /// <summary>

   /// The class to show three disposal function

   /// </summary>

   public class DisposeClass:IDisposable

   {

       public void Close()

       {

           Debug.WriteLine( "Close called!" );

       }

 

       ~DisposeClass()

       {

           Debug.WriteLine( "Destructor called!" );

       }

 

       #region IDisposable Members

 

       public void Dispose()

       {

           // TODO:  Add DisposeClass.Dispose implementation

           Debug.WriteLine( "Dispose called!" );

       }

 

       #endregion

   }

 

对于Close来说不属于真正意义上的释放，除了注意它需要显示被调用外，我在此对它不多说了。而对于析构函数而言，不是在对象离开作用域后立刻被执行，只有在关闭进程或者调用GC.Collect方法的时候才被调用，参看如下的代码运行结果。

       private void Create()

       {

           DisposeClass myClass = new DisposeClass();

       }

 

       private void CallGC()

       {

           GC.Collect();

       }

 

       // Show destructor

       Create();

       Debug.WriteLine( "After created!" );

       CallGC();

 

运行的结果为：

After created!

Destructor called!

 

显然在出了Create函数外，myClass对象的析构函数没有被立刻调用，而是等显示调用GC.Collect才被调用。

 

对于Dispose来说，也需要显示的调用，但是对于继承了IDisposable的类型对象可以使用using这个关键字，这样对象的Dispose方法在出了using范围后会被自动调用。例如：

   using( DisposeClass myClass = new DisposeClass() )

   {

       //other operation here

   }

 

如上运行的结果如下：

Dispose called!

 

那么对于如上DisposeClass类型的Dispose实现来说，事实上GC还需要调用对象的析构函数，按照前面的GC流程来说，GC对于需要调用析构函数的对象来说，至少经过两个步骤，即首先调用对象的析构函数，其次回收内存。也就是说，按照上面所写的Dispose函数，虽说被执行了，但是GC还是需要执行析构函数，那么一个完整的Dispose函数，应该通过调用GC.SuppressFinalize(this )来告诉GC，让它不用再调用对象的析构函数中。那么改写后的DisposeClass如下：

   /// <summary>

   /// The class to show three disposal function

   /// </summary>

   public class DisposeClass:IDisposable

   {

       public void Close()

       {

           Debug.WriteLine( "Close called!" );

       }

 

       ~DisposeClass()

       {

           Debug.WriteLine( "Destructor called!" );

       }

 

       #region IDisposable Members

 

       public void Dispose()

       {

           // TODO:  Add DisposeClass.Dispose implementation

           Debug.WriteLine( "Dispose called!" );

           GC.SuppressFinalize( this );

       }

 

       #endregion

   }

 

通过如下的代码进行测试。

       private void Run()

       {

           using( DisposeClass myClass = new DisposeClass() )

           {

               //other operation here

           }

       }

 

       private void CallGC()

       {

           GC.Collect();

       }

 

       // Show destructor

       Run();

       Debug.WriteLine( "After Run!" );

       CallGC();

 

运行的结果如下：

Dispose called!

After Run!

 

显然对象的析构函数没有被调用。通过如上的实验以及文字说明，大家会得到如下的一个对比表格。

	析构函数	Dispose方法	Close方法
意义	销毁对象	销毁对象	关闭对象资源
调用方式	不能被显示调用，会被GC调用	需要显示调用 或者通过using语句	需要显示调用
调用时机	不确定	确定，在显示调用或者离开using程序块	确定，在显示调用时

 

那么在定义一个类型的时候，是否一定要给出这三个函数地实现呢。

 

我的建议大致如下。

<!--[if !supportLists]-->1．<!--[endif]-->提供析构函数，避免资源未被释放，主要是指非内存资源；

<!--[if !supportLists]-->2．<!--[endif]-->对于Dispose和Close方法来说，需要看所定义的类型所使用的资源（参看前面所说），而决定是否去定义这两个函数；

<!--[if !supportLists]-->3．<!--[endif]-->在实现Dispose方法的时候，一定要加上“GC.SuppressFinalize( this )”语句，避免再让GC调用对象的析构函数。

 

C#程序所使用的内存是受托管的，但不意味着滥用，好地编程习惯有利于提高代码的质量以及程序的运行效率。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1023352

http://www.cnblogs.com/fromchaos/archive/2012/08/27/2658033.html

1、使用性能测试工具dotTrace 3.0，它能够计算出你程序中那些代码占用内存较多

2、强制垃圾回收

3、多dispose，close

4、用timer，每几秒钟调用：SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1);具体见附录。

5、发布的时候选择Release

6、注意代码编写时少产生垃圾，比如String + String就会产生大量的垃圾，可以用StringBuffer.Append

7、this.Dispose();    this.Dispose(True);   this.Close();    GC.Collect();   

8、注意变量的作用域，具体说某个变量如果只是临时使用就不要定义成成员变量。GC是根据关系网去回收资源的。

9、检测是否存在内存泄漏的情况，详情可参见：内存泄漏百度百科

 

定期清理执行垃圾回收代码：

//在程序中用一个计时器，每隔几秒钟调用一次该函数，打开任务管理器，你会有惊奇的发现

#region 内存回收

[DllImport("kernel32.dll", EntryPoint = "SetProcessWorkingSetSize")]

public static extern int SetProcessWorkingSetSize(IntPtr process, int minSize, int maxSize);

/// <summary>

/// 释放内存

/// </summary>

public static void ClearMemory()

{

GC.Collect();

GC.WaitForPendingFinalizers();

if (Environment.OSVersion.Platform == PlatformID.Win32NT)

{

App.SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);

}

}

#endregion

 

SetProcessWorkingSetSize函数的骗局

 

物理内存和虚拟内存

物理内存,在应用中,自然是顾名思义,物理上,真实的插在板子上的内存是多大就是多大了.看机器配置的时候,看的就是这个物理内存.

如果执行的程序很大或很多,就会导致物理内存消耗殆尽.为了解决这个问题,Windows中运用了虚拟内存技术,即拿出一部分硬盘空间来充当内存使用,当内存占用完时,电脑就会自动调用硬盘来充当内存,以缓解内存的紧张.

一个程序,不可避免地要用到虚拟内存,因为不频繁执行或者已经很久没有执行的代码,没有必要留在物理内存中,只会造成浪费;放在虚拟内存中,等执行这部分代码的时候,再调出来.
Windows 的任务管理器可以帮助我们看到进程的虚拟内存.调出任务管理器,点击菜单“查看”－“选择列”,在出现的窗口中,钩上“虚拟内存大小

一个程序到底应该使用多少虚拟内存呢?不一定,但是应该以恰到好处的符合虚拟内存原本作用为最好.
下面将揭穿表面看起来调用了大量图片、大量运行库的程序,为什么才“占用”不到 1 MB 的内存的诡计.

原来是 SetProcessWorkingSetSize 函数

MSDN 对该函数的表述(翻译):使用这个函数来设置应用程序最小和最大的运行空间,只会保留需要的内存.当应用程序被闲置或系统内存太低时,操作系统会自动调用这个机制来设置应用程序的内存.应用程序也可以使用 VirtualLock 来锁住一定范围的内存不被系统释放;当你加大运行空间给应用程序,你能够得到的物理内存取决于系统,这会造成其他应用程序降低性能或系统总体降低性能,这也可能导致请求物理内存的操作失败,例如:建立 进程,线程,内核池,就必须小心的使用该函数.

也就是说,该函数不是节省内存,而是强制把进程的物理内存搬到虚拟内存中.

另外有一些资料上说,该函数“将有可能导致缺页中断,严重影响性能”.
函数原型:
BOOL SetProcessWorkingSetSize(
HANDLE hProcess,
SIZE_T dwMinimumWorkingSetSize,
SIZE_T dwMaximumWorkingSetSize
);
我们用 VB 来做这么一个简单的例子,是程序占用 300 KB 内存吧.

建立一个标准的 VB 工程,在 Form1 中放置一个 Timer1 ,把 Interval 属性设置为 1000 (即 1 秒).然后在代码编辑框中输入以下代码:

Private Declare Function SetProcessWorkingSetSize Lib "kernel32" (ByVal hProcess As Long, ByVal dwMinimumWorkingSetSize As Long, ByVal dwMaximumWorkingSetSize As Long) As Long
Private Declare Function GetCurrentProcess Lib "kernel32" () As Long
Private Sub Timer1_Timer()
SetProcessWorkingSetSize GetCurrentProcess(), 50000, 100000
End Sub
然后生成 工程1.exe,执行,调出任务管理器查看,发现内存占用才 320 KB.如果把定时器关闭,这进程的内存一般 4 MB左右.
必须定时执行该函数,否则虚拟内存会慢慢被调出来,恢复原来的内存大小.
如果要使一个本来需要占用大量内存的程序减低到几百 KB ,使用同样的方法即可.

诡计带来的危害

如果 SetProcessWorkingSetSize 函数被正常使用,是非常有用处的.但是为了蒙骗用户的眼睛,每秒,甚至几十毫秒就把大量内存往虚拟内存里面压,就会带来无可预计的危害.看看这篇文章怎么 说:“因为他只是暂时的将应用程序占用的内存移至虚拟内存,一旦,应用程序被激活或者有操作请求时,这些内存又会被重新占用.如果你强制使用该方法来设置 程序占用的内存,那么可能在一定程度上反而会降低系统性能,因为系统需要频繁的进行内存和硬盘间的页面交换.”.

没错,如果你使用了这类软件,意味着你的硬盘将每秒将 I/O 大量数据;硬盘的磁针将拼命旋转...(当然硬盘磁针不可能不旋转^_^,只是选择得更厉害而已).

不是说 BT 很伤内存吗?不然,因为现在大多 BT 软件都有缓存技术.且看 Bitcomet 官方对缓存技术的说明:“传统BT高速下载时硬盘会响得很厉害,这是大量的随机读取造成的.... BitComet可以由用户设置缓存大小.... 可以明显地看出牺牲一小部分内存作缓存对硬盘的保护作用.”

是不是有种心寒的感觉?一类软件宁愿牺牲内存,也要减少保护硬盘;而另外一类软件,却为了欺骗用户,让CPU、硬盘更加奔波......

抓一个凶手

这类软件不少,我以其中一个桌面工具为例,揭穿它的假面具(不点名字了).运行该软件后,随意操作一下,然后打开进程管理器,把虚拟内存列调出来,找到该进程,如图3:

OK,20 MB 虚拟内存,而只有 632 KB 物理内存.细心的你会发现,大概每 1 秒,该行都有闪烁的感觉,没错,这正是每秒调用 SetProcessWorkingSetSize 的结果.另外,我们打开 Norton Process Viewer ,查看该进程的 CPU 占用情况,如图4:

可以看到,就算没有操作该软件,但是每秒,都有 3% 的CPU占用起伏(虽然这并不能说明什么).另外,内存框中可以看到物理内存和虚拟内存的占用,两者相去甚远.此外,可以用 Hook API 技术来证明每秒调用 SetProcessWorkingSetSize 的行为.

应该怎么做

这篇文章只想让用户了解软件占用资源的实际.而程序员应该把下功夫,真正从代码中减少内存的消耗,而不是一味忽悠用户.调用 SetProcessWorkingSetSize

会带来某些好处,但是何时调用、如何调用应该符合两个要求:
1,在程序暂时不被使用的时候(例如最小化);
2,物理内存和虚拟内存应处于一个合适的比例(而不是 600 KB 比 20 MB 这么荒唐);
3,或者不调用,让 Windows 去处理.

 

 

public void Dispose ()

{

this.Dispose (true);

GC.SuppressFinalize (this);

}

protected virtual void Dispose (bool disposing)

{

if (disposing) free();//优先释放对象的原则
//-----------------------
if (disposing)
   _component = null;
//--------------------
if (disposing && (components != null))
{
   components.Dispose();
}

base.Dispose(disposing);
System.Console.WriteLine("#####ActiveX-Disposed ok");
}


~ComponentDesigner ()

{

this.Dispose (false);

}

}