C#之垃圾回收机制(GC)(转)

转自：http://www.javashuo.com/article/p-gazsdfaq-ck.html

GC的前世与此生

　　虽然本文是以.NET做为目标来说述GC，可是GC的概念并不是才诞生不久。早在1958年，由鼎鼎大名的图林奖得主John McCarthy所实现的Lisp语言就已经提供了GC的功能，这是GC的第一次出现。Lisp的程序员认为内存管理过重要了，因此不能由程序员本身来管理。

　　但后来的日子里Lisp却没有成气候，采用内存手动管理的语言占据了上风，以C为表明。出于一样的理由，不一样的人却又不一样的见解，C程序员认为内存管理过重要了，因此不能由系统来管理，而且讥笑Lisp程序慢如乌龟的运行速度。的确，在那个对每个Byte都要精心计算的年代GC的速度和对系统资源的大量占用使不少人的没法接受。然后，1984年由Dave Ungar开发的Smalltalk语言第一次采用了Generational garbage collection的技术（这个技术在下文中会谈到），可是Smalltalk也没有获得十分普遍的应用。

　　直到20世纪90年代中期GC才以主角的身份登上了历史的舞台，这不得不归功于Java的进步，今日的GC已非吴下阿蒙。Java采用VM（Virtual Machine）机制，由VM来管理程序的运行固然也包括对GC管理。90年代末期.NET出现了，.NET采用了和Java相似的方法由CLR(Common Language Runtime)来管理。这两大阵营的出现将人们引入了以虚拟平台为基础的开发时代，GC也在这个时候愈来愈获得大众的关注。

　　为何要使用GC呢？也能够说是为何要使用内存自动管理？有下面的几个缘由：

　　一、提升了软件开发的抽象度；

　　二、程序员能够将精力集中在实际的问题上而不用分心来管理内存的问题；

　　三、可使模块的接口更加的清晰，减少模块间的偶合；

　　四、大大减小了内存人为管理不当所带来的Bug；

　　五、使内存管理更加高效。

　　总的说来就是GC可使程序员能够从复杂的内存问题中摆脱出来，从而提升了软件开发的速度、质量和安全性。

　　什么是GC

　　GC如其名，就是垃圾收集，固然这里仅就内存而言。Garbage Collector（垃圾收集器，在不至于混淆的状况下也成为GC）以应用程序的root为基础，遍历应用程序在Heap上动态分配的全部对象[2]，经过识别它们是否被引用来肯定哪些对象是已经死亡的、哪些仍须要被使用。已经再也不被应用程序的root或者别的对象所引用的对象就是已经死亡的对象，即所谓的垃圾，须要被回收。这就是GC工做的原理。为了实现这个原理，GC有多种算法。比较常见的算法有Reference Counting，Mark Sweep，Copy Collection等等。目前主流的虚拟系统.NET CLR，Java VM和Rotor都是采用的Mark Sweep算法。

　　1、Mark-Compact 标记压缩算法

　　简单地把.NET的GC算法看做Mark-Compact算法。阶段1: Mark-Sweep 标记清除阶段，先假设heap中全部对象均可以回收，而后找出不能回收的对象，给这些对象打上标记，最后heap中没有打标记的对象都是能够被回收的；阶段2: Compact 压缩阶段，对象回收以后heap内存空间变得不连续，在heap中移动这些对象，使他们从新从heap基地址开始连续排列，相似于磁盘空间的碎片整理。

　　Heap内存通过回收、压缩以后，能够继续采用前面的heap内存分配方法，即仅用一个指针记录heap分配的起始地址就能够。主要处理步骤：将线程挂起→肯定roots→建立reachable objects graph→对象回收→heap压缩→指针修复。能够这样理解roots：heap中对象的引用关系错综复杂（交叉引用、循环引用），造成复杂的graph，roots是CLR在heap以外能够找到的各类入口点。

　　GC搜索roots的地方包括全局对象、静态变量、局部对象、函数调用参数、当前CPU寄存器中的对象指针（还有finalization queue）等。主要能够归为2种类型：已经初始化了的静态变量、线程仍在使用的对象（stack+CPU register） 。 Reachable objects：指根据对象引用关系，从roots出发能够到达的对象。例如当前执行函数的局部变量对象A是一个root object，他的成员变量引用了对象B，则B是一个reachable object。从roots出发能够建立reachable objects graph，剩余对象即为unreachable，能够被回收 。

　　指针修复是由于compact过程移动了heap对象，对象地址发生变化，须要修复全部引用指针，包括stack、CPU register中的指针以及heap中其余对象的引用指针。Debug和release执行模式之间稍有区别，release模式下后续代码没有引用的对象是unreachable的，而debug模式下须要等到当前函数执行完毕，这些对象才会成为unreachable，目的是为了调试时跟踪局部对象的内容。传给了COM+的托管对象也会成为root，而且具备一个引用计数器以兼容COM+的内存管理机制，引用计数器为0时，这些对象才可能成为被回收对象。Pinned objects指分配以后不能移动位置的对象，例如传递给非托管代码的对象（或者使用了fixed关键字），GC在指针修复时没法修改非托管代码中的引用指针，所以将这些对象移动将发生异常。pinned objects会致使heap出现碎片，但大部分状况来讲传给非托管代码的对象应当在GC时可以被回收掉。 　　　　　　

　　2、 Generational 分代算法

　　程序可能使用几百M、几G的内存，对这样的内存区域进行GC操做成本很高，分代算法具有必定统计学基础，对GC的性能改善效果比较明显。将对象按照生命周期分红新的、老的，根据统计分布规律所反映的结果，能够对新、老区域采用不一样的回收策略和算法，增强对新区域的回收处理力度，争取在较短期间隔、较小的内存区域内，以较低成本将执行路径上大量新近抛弃再也不使用的局部对象及时回收掉。分代算法的假设前提条件：

　　一、大量新建立的对象生命周期都比较短，而较老的对象生命周期会更长；

　　二、对部份内存进行回收比基于所有内存的回收操做要快；

　　三、新建立的对象之间关联程度一般较强。heap分配的对象是连续的，关联度较强有利于提升CPU cache的命中率，.NET将heap分红3个代龄区域: Gen 0、Gen 一、Gen 2；

　　Heap分为3个代龄区域，相应的GC有3种方式: # Gen 0 collections, # Gen 1 collections, #Gen 2 collections。若是Gen 0 heap内存达到阀值，则触发0代GC，0代GC后Gen 0中幸存的对象进入Gen1。若是Gen 1的内存达到阀值，则进行1代GC，1代GC将Gen 0 heap和Gen 1 heap一块儿进行回收，幸存的对象进入Gen2。

　　2代GC将Gen 0 heap、Gen 1 heap和Gen 2 heap一块儿回收，Gen 0和Gen 1比较小，这两个代龄加起来老是保持在16M左右；Gen2的大小由应用程序肯定，可能达到几G，所以0代和1代GC的成本很是低，2代GC称为full GC，一般成本很高。粗略的计算0代和1代GC应当能在几毫秒到几十毫秒之间完成，Gen 2 heap比较大时，full GC可能须要花费几秒时间。大体上来说.NET应用运行期间，2代、1代和0代GC的频率应当大体为1:10:100。

　　3、Finalization Queue和Freachable Queue

　　这两个队列和.NET对象所提供的Finalize方法有关。这两个队列并不用于存储真正的对象，而是存储一组指向对象的指针。当程序中使用了new操做符在Managed Heap上分配空间时，GC会对其进行分析，若是该对象含有Finalize方法则在Finalization Queue中添加一个指向该对象的指针。

　　在GC被启动之后，通过Mark阶段分辨出哪些是垃圾。再在垃圾中搜索，若是发现垃圾中有被Finalization Queue中的指针所指向的对象，则将这个对象从垃圾中分离出来，并将指向它的指针移动到Freachable Queue中。这个过程被称为是对象的复生（Resurrection），原本死去的对象就这样被救活了。为何要救活它呢？由于这个对象的Finalize方法尚未被执行，因此不能让它死去。Freachable Queue平时不作什么事，可是一旦里面被添加了指针以后，它就会去触发所指对象的Finalize方法执行，以后将这个指针从队列中剔除，这是对象就能够安静的死去了。

　　.NET Framework的System.GC类提供了控制Finalize的两个方法，ReRegisterForFinalize和SuppressFinalize。前者是请求系统完成对象的Finalize方法，后者是请求系统不要完成对象的Finalize方法。ReRegisterForFinalize方法其实就是将指向对象的指针从新添加到Finalization Queue中。这就出现了一个颇有趣的现象，由于在Finalization Queue中的对象能够复生，若是在对象的Finalize方法中调用ReRegisterForFinalize方法，这样就造成了一个在堆上永远不会死去的对象，像凤凰涅槃同样每次死的时候均可以复生。

　　托管资源：

　　.NET中的全部类型都是（直接或间接）从System.Object类型派生的。

　　CTS中的类型被分红两大类——引用类型（reference type，又叫托管类型[managed type]），分配在内存堆上；值类型（value type），分配在堆栈上。如图：

　　值类型在栈里，先进后出，值类型变量的生命有前后顺序，这个确保了值类型变量在退出做用域之前会释放资源。比引用类型更简单和高效。堆栈是从高地址往低地址分配内存。

　　引用类型分配在托管堆(Managed Heap)上，声明一个变量在栈上保存，当使用new建立对象时，会把对象的地址存储在这个变量里。托管堆相反，从低地址往高地址分配内存，如图：

　　.NET中超过80%的资源都是托管资源。

　　非托管资源：　

　　ApplicationContext, Brush, Component, ComponentDesigner, Container, Context, Cursor, FileStream, Font, Icon, Image, Matrix, Object, OdbcDataReader, OleDBDataReader, Pen, Regex, Socket, StreamWriter, Timer, Tooltip, 文件句柄, GDI资源, 数据库链接等等资源。可能在使用的时候不少都没有注意到！

　　.NET的GC机制有这样两个问题：

　　首先，GC并非能释放全部的资源。它不能自动释放非托管资源。

　　第二，GC并非实时性的，这将会形成系统性能上的瓶颈和不肯定性。

　　GC并非实时性的，这会形成系统性能上的瓶颈和不肯定性。因此有了IDisposable接口，IDisposable接口定义了Dispose方法，这个方法用来供程序员显式调用以释放非托管资源。使用using语句能够简化资源管理。

　　示例：

///summary
/// 执行SQL语句，返回影响的记录数
////summary
///param name="SQLString"SQL语句/param
///returns影响的记录数/returns
publicstaticint ExecuteSql(string SQLString)
{
    using (SqlConnection connection =new SqlConnection(connectionString))
    {
        using (SqlCommand cmd =new SqlCommand(SQLString, connection))
        {
            try
            {
                connection.Open();
                int rows = cmd.ExecuteNonQuery();
                return rows;
            }
            catch (System.Data.SqlClient.SqlException e)
            {
                connection.Close();
                throw e;
            }
            finally
            {
                cmd.Dispose();
                connection.Close();
            }
        }
    }
}

　　当你用Dispose方法释放未托管对象的时候，应该调用GC.SuppressFinalize。若是对象正在终结队列(finalization queue), GC.SuppressFinalize会阻止GC调用Finalize方法。由于Finalize方法的调用会牺牲部分性能。若是你的Dispose方法已经对委托管资源做了清理，就不必让GC再调用对象的Finalize方法(MSDN)。附上MSDN的代码，你们能够参考。

publicclass BaseResource : IDisposable
{
    // 指向外部非托管资源
private IntPtr handle;
    // 此类使用的其它托管资源.
private Component Components;
    // 跟踪是否调用.Dispose方法，标识位，控制垃圾收集器的行为
    privatebool disposed =false;
    // 构造函数
public BaseResource()
    {
        // Insert appropriate constructor code here.
    }
    // 实现接口IDisposable.
    // 不能声明为虚方法virtual.
    // 子类不能重写这个方法.
    publicvoid Dispose()
    {
        Dispose(true);
        // 离开终结队列Finalization queue
        // 设置对象的阻止终结器代码
        //
        GC.SuppressFinalize(this);
    }
    // Dispose(bool disposing) 执行分两种不一样的状况.
    // 若是disposing 等于 true, 方法已经被调用
    // 或者间接被用户代码调用. 托管和非托管的代码都能被释放
    // 若是disposing 等于false, 方法已经被终结器 finalizer 从内部调用过，
    //你就不能在引用其余对象，只有非托管资源能够被释放。
    protectedvirtualvoid Dispose(bool disposing)
    {
        // 检查Dispose 是否被调用过.
if (!this.disposed)
        {
            // 若是等于true, 释放全部托管和非托管资源
if (disposing)
            {
                // 释放托管资源.
                Components.Dispose();
            }
            // 释放非托管资源，若是disposing为 false,
            // 只会执行下面的代码.
            CloseHandle(handle);
            handle = IntPtr.Zero;
            // 注意这里是非线程安全的.
            // 在托管资源释放之后能够启动其它线程销毁对象，
            // 可是在disposed标记设置为true前
            // 若是线程安全是必须的，客户端必须实现。
        }
        disposed =true;
    }
    // 使用interop 调用方法
    // 清除非托管资源.
    [System.Runtime.InteropServices.DllImport("Kernel32")]
    privateexternstatic Boolean CloseHandle(IntPtr handle);
    // 使用C# 析构函数来实现终结器代码
    // 这个只在Dispose方法没被调用的前提下，才能调用执行。
    // 若是你给基类终结的机会.
    // 不要给子类提供析构函数.
~BaseResource()
    {
        // 不要重复建立清理的代码.
        // 基于可靠性和可维护性考虑，调用Dispose(false) 是最佳的方式
        Dispose(false);
    }
    // 容许你屡次调用Dispose方法,
    // 可是会抛出异常若是对象已经释放。
    // 不论你什么时间处理对象都会核查对象的是否释放,
    // check to see if it has been disposed.
publicvoid DoSomething()
    {
        if (this.disposed)
        {
            thrownew ObjectDisposedException();
        }
    }
    // 不要设置方法为virtual.
    // 继承类不容许重写这个方法
    publicvoid Close()
    {
        // 无参数调用Dispose参数.
        Dispose();
    }
    publicstaticvoid Main()
    {
        // Insert code here to create
        // and use a BaseResource object.
    }
}

　　GC.Collect() 方法

　　做用：强制进行垃圾回收。

　　GC的方法：

名称	说明
Collect()	强制对全部代进行即时垃圾回收。
Collect(Int32)	强制对零代到指定代进行即时垃圾回收。
Collect(Int32, GCCollectionMode)	强制在 GCCollectionMode 值所指定的时间对零代到指定代进行垃圾回收

　　GC注意事项：

　　一、只管理内存，非托管资源，如文件句柄，GDI资源，数据库链接等还须要用户去管理。

　　二、循环引用，网状结构等的实现会变得简单。GC的标志-压缩算法能有效的检测这些关系，并将再也不被引用的网状结构总体删除。

　　三、GC经过从程序的根对象开始遍从来检测一个对象是否可被其余对象访问，而不是用相似于COM中的引用计数方法。

　　四、GC在一个独立的线程中运行来删除再也不被引用的内存。

　　五、GC每次运行时会压缩托管堆。

　　六、你必须对非托管资源的释放负责。能够经过在类型中定义Finalizer来保证资源获得释放。

　　七、对象的Finalizer被执行的时间是在对象再也不被引用后的某个不肯定的时间。注意并不是和C++中同样在对象超出声明周期时当即执行析构函数

　　八、Finalizer的使用有性能上的代价。须要Finalization的对象不会当即被清除，而须要先执行Finalizer.Finalizer，不是在GC执行的线程被调用。GC把每个须要执行Finalizer的对象放到一个队列中去，而后启动另外一个线程来执行全部这些Finalizer，而GC线程继续去删除其余待回收的对象。在下一个GC周期，这些执行完Finalizer的对象的内存才会被回收。

　　九、.NET GC使用"代"(generations)的概念来优化性能。代帮助GC更迅速的识别那些最可能成为垃圾的对象。在上次执行完垃圾回收后新建立的对象为第0代对象。经历了一次GC周期的对象为第1代对象。经历了两次或更多的GC周期的对象为第2代对象。代的做用是为了区分局部变量和须要在应用程序生存周期中一直存活的对象。大部分第0代对象是局部变量。成员变量和全局变量很快变成第1代对象并最终成为第2代对象。

　　十、GC对不一样代的对象执行不一样的检查策略以优化性能。每一个GC周期都会检查第0代对象。大约1/10的GC周期检查第0代和第1代对象。大约1/100的GC周期检查全部的对象。从新思考Finalization的代价：须要Finalization的对象可能比不须要Finalization在内存中停留额外9个GC周期。若是此时它尚未被Finalize，就变成第2代对象，从而在内存中停留更长时间。