编译：赵玉开
链接：http://www.ki4.cn/
有了Microsoft.Net clr中的垃圾接纳机制递次员不须要再关注什么时刻开释内存，开释内存这件事儿完整由GC做了，对递次员来说是通明的。尽管如此，作为一个.Net递次员很有必要明白垃圾接纳是如何事变的。这篇文章我们就来看下.Net是如何分派和治理托管内存的，以后再一步一步形貌垃圾接纳器事变的算法机制。
为递次设想一个恰当的内存治理战略是难题的也是乏味的，这个事变还会影响你专注于处置惩罚递次自身要处置惩罚的题目。有无一种内置的要领能够协助开发人员处置惩罚内存治理的题目呢？固然有了，在.Net中就是GC，垃圾接纳。
让我们想一下，每一个递次都要运用内存资本：比方屏幕显现，网络衔接，数据库资本等等。现实上，在一个面向对象环境中，每一种范例都须要占用一点内存资本来寄存他的数据，对象须要根据以下的步骤运用内存：
1. 为范例分派内存空间
2. 初始化内存，将内存设置为可用状况
3. 存取对象的成员
4. 烧毁对象，使内存变成清空状况
5. 开释内存
这类貌似简朴的内存运用形式致使过许多的递次题目，有时刻递次员能够会遗忘开释不再运用的对象，有时刻又会试图接见已开释的对象。这两种bug一般都有肯定的隐蔽性，不轻易发明，他们不像逻辑毛病，发清楚明了就能够修正掉。他们能够会在递次运转一段时候以后内存走漏致使不测的崩溃。事实上，有许多东西能够协助开发人员检测内存题目，比方：使命治理器，System Monitor AcitvieX Control, 以及Rational的Purify。
而GC能够完整不须要开发人员去关注什么时刻开释内存。然则，垃圾接纳器并非能够治理内存中的一切资本。有些资本垃圾接纳器不晓得该如何接纳他们，这部份资本就须要开发人员本身写代码完成接纳。在.Net framework中，开发人员一般会把清算这类资本的代码写到Close、Dispose或许Finalize要领中，稍后我们会看下Finalize要领，这个要领垃圾接纳器会自动挪用。
不过，有许多对象是不须要本身完成开释资本的代码的，比方：Rectangle，清空它只须要清空它的left，right，width，height字段就能够了，这垃圾接纳器完整能够做。下面让我们来看下内存是如何分派给对象运用的。
对象分派：
.Net clr把一切的援用对象都分派到托管堆上。这一点很像c-runtime堆，不过你不须要关注什么时刻开释对象，对象会在不用时自动开释。如许，就涌现一个题目，垃圾接纳器是如何晓得一个对象不再运用该接纳了呢？我们稍后诠释这个题目。
如今有几种垃圾接纳算法，每一种算法都为一种特定的环境做了机能优化，这篇文章我们关注的是clr的垃圾接纳算法。让我们从一个基本观点谈起。
当一个历程初始化以后，运转时会保存一段一连的空缺内存空间，这块内存空间就是托管堆。托管堆会纪录一个指针，我们叫它NextObjPtr，这个指针指向下一个对象的分派地点，最初的时刻，这个指针指向托管堆的肇端位置。
应用递次运用new操纵符建立一个新对象，这个操纵符首先要确认托管堆盈余空间能放得下这个对象，假如能放得下，就把NextObjPtr指针指向这个对象，然后挪用对象的组织函数，new操纵符返回对象的地点。
图1托管堆
这时刻，NextObjPtr指向托管堆上下一个对象分派的位置，图1显现一个托管堆中有三个对象A、B和C。下一个对象会放在NextObjPtr指向的位置（紧挨着C对象）
如今让我们再看一下c-runtime堆如何分派内存。在c-runtime堆，分派内存须要遍历一个链表的数据结构，直到找到一个充足大的内存块，这个内存块有能够会被拆分，拆分后链表中的指针要指向盈余内存空间，要确保链表的无缺。关于托管堆，分派一个对象只是修正NextObjPtr指针的指向，这个速率是非常快的。事实上，在托管堆上分派一个对象和在线程栈上分派内存的速率很靠近。
到目前为止，托管堆上分派内存的速率好像比在c-runtime堆上的更快，完成上也更简朴一些。固然，托管堆取得这个上风是由于做了一个假定：地点空间是无穷的。很显然这个假定是毛病的。必需有一种机制保证这个假定建立。这个机制就是垃圾接纳器。让我们看下它如何事变。
当应用递次挪用new操纵符建立对象时，有能够已没有内存来寄存这个对象了。托管堆能够检测到NextObjPtr指向的空间是不是超过了堆的大小，假如超过了就申明托管堆满了，就须要做一次垃圾接纳了。
在现实中，在0代堆满了以后就会触发一次垃圾接纳。“代”是垃圾接纳器提拔机能的一种完成机制。“代”的意义是：新建立的对象是年轻一代，而在接纳操纵发作之前没有被接纳掉的对象是较老的对象。将对象分红几代能够许可垃圾接纳器只接纳某一代的对象，而不是接纳一切对象。
垃圾接纳算法：
垃圾接纳器搜检看是不是存在应用递次不再运用的对象。假如如许的对象存在，那末这些对象占用的空间就能够被接纳（假如堆上没有充足的内存可用，那末new操纵符就会抛出OutofMemoryException）。你能够会问垃圾接纳器是如何推断一个对象是不是还在用呢？这个题目不太轻易获得答案。
每一个应用递次都有一组根对象，根是一些存储位置，他们能够指向托管堆上的某个地点，也多是null。比方，一切的全局和静态对象指针是应用递次的根对象，别的在线程栈上的局部变量/参数也是应用递次的根对象，另有CPU寄存器中的指向托管堆的对象也是根对象。存活的根对象列表由JIT（just-in-time）编译器和clr保护，垃圾接纳器能够接见这些根对象的。
当垃圾接纳器最先运转，它会假定托管堆上的一切对象都是垃圾。也就是说，假定没有根对象，也没有根对象援用的对象。然后垃圾接纳器最先遍历根对象并构建一个由一切和根对象之间有援用关联对象组成的图。
图2显现，托管堆上应用递次的根对象是A，C，D和F，这几个对象就是图的一部份，然后对象D援用了对象H，那末对象H也被增加到图中；垃圾接纳器会轮回遍历一切可达对象。
图2 托管堆上的对象
垃圾接纳器会挨个遍历根对象和援用对象。假如垃圾接纳器发明一个对象已在图中就会换一个途径继承遍历。如许做有两个目标：一是进步机能，二是防止无穷轮回。
一切的根对象都搜检完以后，垃圾接纳器的图中就有了应用递次中一切的可达对象。托管堆上一切不在这个图上的对象就是要做接纳的垃圾对象了。构建好可达对象图以后垃圾接纳器最先线性的遍历托管堆，找到一连垃圾对象块（能够以为是余暇内存）。然后垃圾接纳器将非垃圾对象挪动到一同（运用c语言中的memcpy函数），掩盖一切的内存碎片。固然，挪动对象时要禁用一切对象的指针（由于他们都多是毛病的了）。因而垃圾接纳器必需修正应用递次的根对象使他们指向对象的新内存地点。另外，假如某个对象包含另一个对象的指针，垃圾接纳器也要担任修正援用。图3显现了一次接纳以后的托管堆。
图3 接纳以后的托管堆
如图3所示在接纳以后，一切的垃圾对象都被标识出来，而一切的非垃圾对象被挪动到一同。一切的非垃圾对象的指针也被修正成挪动后的内存地点，NextObjPtr指向末了一个非垃圾对象的背面。这时刻new操纵符就能够继承胜利的建立对象了。
如你看到的，垃圾接纳会有显著的机能丧失，这是运用托管堆的一个显著的瑕玷。 不过，要记着内存接纳操纵旨在托管堆慢了以后才会实行。在满之前托管堆的机能比c-runtime堆的机能好要好。运转时垃圾接纳器还会做一些机能优化，我们鄙人一篇文章中议论这个。
下面的代码申清楚明了对象是如何被建立治理的：
class Application {
public static int Main(String[] args) {
// ArrayList object created in heap, myArray is now a root
ArrayList myArray = new ArrayList();
// Create 10000 objects in the heap
for (int x = 0; x < 10000; x++) {
myArray.Add(new Object()); // Object object created in heap
}
// Right now, myArray is a root (on the thread's stack). So,
// myArray is reachable and the 10000 objects it points to are also
// reachable.
Console.WriteLine(a.Length);
// After the last reference to myArray in the code, myArray is not
// a root.
// Note that the method doesn't have to return, the JIT compiler
// knows
// to make myArray not a root after the last reference to it in the
// code.
// Since myArray is not a root, all 10001 objects are not reachable
// and are considered garbage. However, the objects are not
// collected until a GC is performed.
}
}
或许你会问，GC这么好，为何ANSI C++中没有它呢？ 缘由是垃圾接纳器必需能找到应用递次的根对象列表，必需找到对象的指针。而在C++中对象的指针之间是能够互相转换的，没有办法晓得指针指向的是一个什么对象的指针。在CLR中，托管堆晓得对象的现实范例。而元数据（metadata）信息能够用来推断对象援用了什么成员对象。
垃圾接纳和Finalization
垃圾接纳器供应了一个分外的功用，它能够在对象被标识为垃圾后自动挪用其Finalize要领（条件是对象重写了object的Finalize要领）。
Finalize要领是object对象的一个虚要领，假如须要你能够重写这个要领，然则这个要领只能经由过程相似c++析构函数的体式格局重写。比方：
{
~Foo(){
Console.WriteLine(“Foo Finalize”);
}
}
这里用过C++的递次员要特别注重，Finalize要领的写法和C++的析构函数完整一样，然则，.Net 中的Finalize要领和析构函数的倒是不一样的，托管对象是不能被析构的，只能经由过程垃圾接纳接纳。
当你设想一个类时，最好防止重写Finalize要领，缘由以下：
1. 完成Finalize的对象会被提拔到更老的“代”，这会增添内存压力，使对象和此对象的关联对象不能在成为垃圾的第一时候接纳掉。
2. 这些对象分派时候会更长
3. 让垃圾接纳器实行Finalize要领会显著的消耗机能。请记着，每一个完成了Finalize要领的对象都须要实行Finalize要领，假如有一个长度为10000的数组对象，每一个对象都须要实行Finalize要领
4. 重写Finalize要领的对象能够会 援用其他没有完成Finalize要领的对象，这些对象也会耽误接纳
5. 你没有办法掌握什么时刻实行Finalize要领。假如要在Finalize要领中开释相似数据库衔接之类的资本，就有能够致使数据库资本在时刻后良久才得以开释
6. 当递次崩溃时，一些对象还被援用，他们的Finalize要领就没有时机实行了。这类状况会在背景线程运用对象，或许对象在递次退出时，或许AppDomain卸载时。别的，默许状况下，当应用递次被强迫结束时Finalize要领也不会实行。固然一切的操纵体系资本会被接纳；然则在托管堆上的对象不会接纳。你能够经由过程挪用GC的RequestFinalizeOnShutdown要领转变这类行动。
7. 运转时不能掌握多个对象Finalize要领实行的递次。而有时刻对象的烧毁能够有递次性
假如你定义的对象必需完成Finalize要领，那末要确保Finalize要领尽量快的实行，要防止一切能够引发壅塞的操纵，包含任何线程同步操纵。别的，要确保Finalize要领不会引发任何非常，假如有非常垃圾接纳器会继承实行其他对象的Finalize要领直接疏忽掉非常。
当编译器生成代码时会自动在组织函数上挪用基类的组织函数。一样C++的编译器也会为析构函数自动增加基类析构函数的挪用。然则，.Net中的Finalize函数不是如许子，编译器不会对Finalize要领做特别处置惩罚。假如你想在Finalize要领中挪用父类的Finalize要领，必需本身显现增加挪用代码。
请注重在C#中Finalize要领的写法和c++中的析构函数一样，然则C#不支持析构函数，不要让这类写法诳骗你。
GC挪用Finalize要领的内部完成
外表看，垃圾接纳器嗲用Finalize要领很简朴，你建立一个对象，当对象接纳时挪用它的Finalize要领。然则事实上要庞杂一些。
当应用递次建立一个新对象时，new操纵符在堆上分派内存。假如对象完成了Finalize要领。对象的指针会放到闭幕行列中。闭幕行列是由垃圾接纳器掌握的内部数据结构。在行列中每一个对象在接纳时都须要挪用它们的Finalize要领。
下图显现的堆上包含几个对象，个中一些对象是跟对象，一些对象不是。当对象C、E、F、I和J建立时，体系会检测这些对象完成了Finalize要领，并将它们的指针放到闭幕行列中。
Finalize要领要做的事变一般是接纳垃圾接纳器不能接纳的资本，比方文件句柄，数据库衔接等等。
当垃圾接纳时，对象B、E、G、H、I和J被标记为垃圾。垃圾接纳器扫描闭幕行列找到这些对象的指针。当发明对象指针时，指针会被挪动到Freachable行列。Freachable行列是另一个由垃圾接纳器掌握的内部数据结构。在Freachable行列中的每一个对象的Finalize要领将实行。
垃圾接纳以后，托管堆如图6所示。你能够看到对象B、G、H已被接纳了，由于这几个对象没有Finalize要领。然则对象E、I、J还没有被接纳掉，由于他们的Finalize要领还没有实行。
图5 垃圾接纳后的托管堆
递次运转时会有一个特地的线程担任挪用Freachable行列中对象的Finalize要领。当Freachable行列为空时，这个线程会休眠，当行列中有对象时，线程被叫醒，移除行列中的对象，并挪用它们的Finalize要领。因而在实行Finalize要领时不要希图接见线程的local storage。
闭幕行列（finalization queue）和Freachable行列之间的交互很奇妙。首先让我通知你freachable的名字是如何来的。F显然是finalization；在此行列中的每一个对象都在守候实行他们的Finalize要领；reachable意义是这些对象来了。另一种说法，Freachable行列中的对象被以为是跟对象，就像是全局变量或静态变量。因而，假如一个对象在freachable行列中，那末这个对象就不是垃圾。
简短点说，当一个对象是不可达的，垃圾接纳器会以为这个对象是垃圾。那末，当垃圾接纳器将对象从闭幕行列挪动到Freachable行列中，这些对象就不再是垃圾了，它们的内存也不会接纳。从这一点上来说，垃圾接纳器已完成标识垃圾，一些对象被标识成垃圾又被从新以为成非垃圾对象。垃圾接纳器接纳紧缩内存，清空freachable行列，实行行列中每一个对象的Finalize要领。
图6 再次实行垃圾接纳后的托管堆
再次动身垃圾接纳以后，完成Finalize要领的对象才被真正的接纳。这些对象的Finalize要领已实行过了，Freachable行列清空了。
垃圾接纳让对象回生
在前面部份我们已说了，当递次不运用某个对象时，这个对象会被接纳。然则，假如对象完成了Finalize要领，只要当对象的Finalize要领实行以后才会以为这个对象是可接纳对象并真正接纳其内存。换句话说，这类对象会先被标识为垃圾，然后放到freachable行列中回生，然后实行Finalize以后才被接纳。恰是Finalize要领的挪用，让这类对象有时机回生，我们能够在Finalize要领中让某个对象强援用这个对象；那末垃圾接纳器就以为这个对象不再是垃圾了，对象就回生了。
以下回生演示代码：
public class Foo {
~Foo(){
Application.ObjHolder = this;
}
}
class Application{
static public Object ObjHolder = null;
}
在这类状况下，当对象的Finalize要领实行以后，对象被Application的静态字段ObjHolder强援用，成为根对象。这个对象就回生了，而这个对象援用的对象也就回生了，然则这些对象的Finalize要领能够已实行过了，能够会故意想不到的毛病发作。
事实上，当你设想本身的范例时，对象的闭幕和回生有能够完整不可掌握。这不是一个好征象；处置惩罚这类状况的经常使用做法是在类中定义一个bool变量来示意对象是不是实行过了Finalize要领，假如实行过Finalize要领，再实行其他要领时就抛出非常。
如今，假如有其他的代码片断又将Application.ObjHolder设置为null，这个对象变成不可达对象。终究垃圾接纳器会把对象当做垃圾并接纳对象内存。请注重这一次对象不会涌如今finalization行列中，它的Finalize要领也不会再实行了。
回生只要有限的几种用途，你应当尽量防止运用回生。尽管如此，当运用回生时，最好从新将对象增加到闭幕行列中，GC供应了静态要领ReRegisterForFinalize要领做这件事：
以下代码:
public class Foo{
~Foo(){
Application.ObjHolder = this;
GC.ReRegisterForFinalize(this);
}
}
当对象回生时，从新将对象增加到回生行列中。须要注重的时假如一个对象已在闭幕行列中，然后又挪用了GC.ReRegisterForFinalize(obj)要领会致使此对象的Finalize要领反复实行。
垃圾接纳机制的目标是为开发人员简化内存治理。
下一篇我们谈一下弱援用的作用，垃圾接纳中的“代”，多线程中的垃圾接纳和与垃圾接纳相干的机能计数器。
以上就是.Net 垃圾接纳机制道理（一）的内容，更多相干内容请关注ki4网（www.ki4.cn）！
