.NET面试题解析(06)-GC与内存管理

  1. 云栖社区>
  2. 博客>
  3. 正文

.NET面试题解析(06)-GC与内存管理

莫问今朝乄 2018-02-01 11:02:00 浏览774
展开阅读全文

转自:http://www.cnblogs.com/anding/p/5260319.html

  常见面试题目:

1. 简述一下一个引用对象的生命周期?

2. 创建下面对象实例,需要申请多少内存空间?

public class User
{
    public int Age { get; set; }
    public string Name { get; set; }

    public string _Name = "123" + "abc";
    public List<string> _Names;
}

3. 什么是垃圾?

4. GC是什么,简述一下GC的工作方式?

5. GC进行垃圾回收时的主要流程是?

6. GC在哪些情况下回进行回收工作?

7. using() 语法是如何确保对象资源被释放的?如果内部出现异常依然会释放资源吗?

8. 解释一下C#里的析构函数?为什么有些编程建议里不推荐使用析构函数呢?

9. Finalize() 和 Dispose() 之间的区别?

10. Dispose和Finalize方法在何时被调用?

11. .NET中的托管堆中是否可能出现内存泄露的现象?

12. 在托管堆上创建新对象有哪几种常见方式?

  深入GC与内存管理

托管堆中存放引用类型对象,因此GC的内存管理的目标主要都是引用类型对象,本文中涉及的对象如无明确说明都指的是引用类型对象。

微笑 对象创建及生命周期

一个对象的生命周期简单概括就是:创建>使用>释放,在.NET中一个对象的生命周期:

  • new创建对象并分配内存
  • 对象初始化
  • 对象操作、使用
  • 资源清理(非托管资源)
  • GC垃圾回收

那其中重要的一个环节,就是对象的创建,大部分的对象创建都是开始于关键字new。为什么说是大部分呢,因为有个别引用类型是由专门IL指令的,比如string有ldstr指令(参考前面的文章:.NET面试题解析(03)-string与字符串操作),0基数组好像也有一个专门指令。

引用对象都是分配在托管堆上的, 先来看看托管堆的基本结构,如下图,托管堆中的对象是顺序存放的,托管堆维护着一个指针NextObjPtr,它指向下一个对象在堆中的分配位置。

创建一个新对象的主要流程:

image

以题目2中的代码为例,模拟一个对象的创建过程:

public class User
{
    public int Age { get; set; }
    public string Name { get; set; }

    public string _Name = "123" + "abc";
    public List<string> _Names;
}
  • 对象大小估算,共计40个字节:
    • 属性Age值类型Int,4字节;
    • 属性Name,引用类型,初始为NULL,4个字节,指向空地址;
    • 字段_Name初始赋值了,由前面的文章(.NET面试题解析(03)-string与字符串操作)可知,代码会被编译器优化为_Name=”123abc”。一个字符两个字节,字符串占用2×6+8(附加成员:4字节TypeHandle地址,4字节同步索引块)=20字节,总共内存大小=字符串对象20字节+_Name指向字符串的内存地址4字节=24字节;
    • 引用类型字段List<string> _Names初始默认为NULL,4个字节;
    • User对象的初始附加成员(4字节TypeHandle地址,4字节同步索引块)8个字节;
  • 内存申请: 申请44个字节的内存块,从指针NextObjPtr开始验证,空间是否足够,若不够则触发垃圾回收。
  • 内存分配: 从指针NextObjPtr处开始划分44个字节内存块。
  • 对象初始化: 首先初始化对象附加成员,再调用User对象的构造函数,对成员初始化,值类型默认初始为0,引用类型默认初始化为NULL;
  • 托管堆指针后移: 指针NextObjPtr后移44个字节。
  • 返回内存地址: 返回对象的内存地址给引用变量。

吐舌笑脸 GC垃圾回收

GC是垃圾回收(Garbage Collect)的缩写,是.NET核心机制的重要部分。她的基本工作原理就是遍历托管堆中的对象,标记哪些被使用对象(那些没人使用的就是所谓的垃圾),然后把可达对象转移到一个连续的地址空间(也叫压缩),其余的所有没用的对象内存被回收掉。

首先,需要再次强调一下托管堆内存的结构,如下图,很明确的表明了,只有GC堆才是GC的管辖区域,关于加载堆在前面文中有提到过(.NET面试题解析(04)-类型、方法与继承)。GC堆里面为了提高内存管理效率等因素,有分成多个部分,其中 两个主要部分:

  • 0/1/2代:代龄(Generation)在后面有专门说到;
  • 大对象堆(Large Object Heap),大于85000字节的大对象会分配到这个区域,这个区域的主要特点就是:不会轻易被回收;就是回收了也不会被压缩(因为对象太大,移动复制的成本太高了);

image

图3(Figure-3)

什么是垃圾?简单理解就是没有被引用的对象。

垃圾回收的基本流程包含以下三个关键步骤:

① 标记

先假设所有对象都是垃圾,根据应用程序根指针Root遍历堆上的每一个引用对象,生成可达对象图,对于还在使用的对象(可达对象)进行标记(其实就是在对象同步索引块中开启一个标示位)。

其中Root根指针保存了当前所有需要使用的对象引用,他其实只是一个统称,意思就是这些对象当前还在使用,主要包含:静态对象/静态字段的引用;线程栈引用(局部变量、方法参数、栈帧);任何引用对象的CPU寄存器;根引用对象中引用的对象;GC Handle table;Freachable队列等。

② 清除

针对所有不可达对象进行清除操作,针对普通对象直接回收内存,而对于实现了终结器的对象(实现了析构函数的对象)需要单独回收处理。清除之后,内存就会变得不连续了,就是步骤3的工作了。

③ 压缩

把剩下的对象转移到一个连续的内存,因为这些对象地址变了,还需要把那些Root跟指针的地址修改为移动后的新地址。

垃圾回收的过程示意图如下:

alt

 

垃圾回收的过程是不是还挺辛苦的,因此建议不要随意手动调用垃圾回收GC.Collect(),GC会选择合适的时机、合适的方式进行内存回收的。

吐舌笑脸 关于代龄(Generation)

当然,实际的垃圾回收过程可能比上面的要复杂,如果没次都扫描托管堆内的所有对象实例,这样做太耗费时间而且没有必要。分代(Generation)算法是CLR垃圾回收器采用的一种机制,它唯一的目的就是提升应用程序的性能。分代回收,速度显然快于回收整个堆。分代(Generation)算法的假设前提条件:

1、大量新创建的对象生命周期都比较短,而较老的对象生命周期会更长 
2、对部分内存进行回收比基于全部内存的回收操作要快 
3、新创建的对象之间关联程度通常较强。heap分配的对象是连续的,关联度较强有利于提高CPU cache的命中率

如图3,.NET将托管堆分成3个代龄区域: Gen 0、Gen 1、Gen 2:

  • 第0代,最新分配在堆上的对象,从来没有被垃圾收集过。任何一个新对象,当它第一次被分配在托管堆上时,就是第0代(大于85000的大对象除外)。 
  • 第1代,0代满了会触发0代的垃圾回收,0代垃圾回收后,剩下的对象会搬到1代。 
  • 第2代,当0代、1代满了,会触发0代、1代的垃圾回收,第0代升为第1代,第1代升为第2代。

alt

大部分情况,GC只需要回收0代即可,这样可以显著提高GC的效率,而且GC使用启发式内存优化算法,自动优化内存负载,自动调整各代的内存大小。

吐舌笑脸 非托管资源回收

.NET中提供释放非托管资源的方式主要是:Finalize() 和 Dispose()。

Dispose():

常用的大多是Dispose模式,主要实现方式就是实现IDisposable接口,下面是一个简单的IDisposable接口实现方式。

public class SomeType : IDisposable
{
    public MemoryStream _MemoryStream;
    public void Dispose()
    {
        if (_MemoryStream != null) _MemoryStream.Dispose();
    }
}

Dispose需要手动调用,在.NET中有两中调用方式:

//方式1:显示接口调用
SomeType st1=new SomeType();
//do sth
st1.Dispose();

//方式2:using()语法调用,自动执行Dispose接口
using (var st2 = new SomeType())
{
    //do sth
}

第一种方式,显示调用,缺点显而易见,如果程序猿忘了调用接口,则会造成资源得不到释放。或者调用前出现异常,当然这一点可以使用try…finally避免。

一般都建议使用第二种实现方式,他可以保证无论如何Dispose接口都可以得到调用,原理其实很简单,using()的IL代码如下图,因为using只是一种语法形式,本质上还是try…finally的结构。

image

 

Finalize() :终结器(析构函数)

首先了解下Finalize方法的来源,她是来自System.Object中受保护的虚方法Finalize,无法被子类显示重写,也无法显示调用,是不是有点怪?。她的作用就是用来释放非托管资源,由GC来执行回收,因此可以保证非托管资源可以被释放。

  • 无法被子类显示重写:.NET提供类似C++析构函数的形式来实现重写,因此也有称之为析构函数,但其实她只是外表和C++里的析构函数像而已。
  • 无法显示调用:由GC来管理和执行释放,不需要手动执行了,再也不用担心猿们忘了调用Dispose了。

所有实现了终结器(析构函数)的对象,会被GC特殊照顾,GC的终止化队列跟踪所有实现了Finalize方法(析构函数)的对象。

  • 当CLR在托管堆上分配对象时,GC检查该对象是否实现了自定义的Finalize方法(析构函数)。如果是,对象会被标记为可终结的,同时这个对象的指针被保存在名为终结队列的内部队列中。终结队列是一个由垃圾回收器维护的表,它指向每一个在从堆上删除之前必须被终结的对象。
  • 当GC执行并且检测到一个不被使用的对象时,需要进一步检查“终结队列”来查询该对象类型是否含有Finalize方法,如果没有则将该对象视为垃圾,如果存在则将该对象的引用移动到另外一张Freachable列表,此时对象会被复活一次。
  • CLR将有一个单独的高优先级线程负责处理Freachable列表,就是依次调用其中每个对象的Finalize方法,然后删除引用,这时对象实例就被视为不再被使用,对象再次变成垃圾。
  • 下一个GC执行时,将释放已经被调用Finalize方法的那些对象实例。

上面的过程是不是很复杂!是就对了,如果想彻底搞清楚,没有捷径,不要偷懒,还是去看书吧!

简单总结一下:Finalize()可以确保非托管资源会被释放,但需要很多额外的工作(比如终结对象特殊管理),而且GC需要执行两次才会真正释放资源。听上去好像缺点很多,她唯一的优点就是不需要显示调用。

有些编程意见或程序猿不建议大家使用Finalize,尽量使用Dispose代替,我觉得可能主要原因在于:第一是Finalize本身性能并不好;其次很多人搞不清楚Finalize的原理,可能会滥用,导致内存泄露。因此就干脆别用了,其实微软是推荐大家使用的,不过是和Dispose一起使用,同时实现IDisposable接口和Finalize(析构函数),其实FCL中很多类库都是这样实现的,这样可以兼具两者的优点:

  • 如果调用了Dispose,则可以忽略对象的终结器,对象一次就回收了;
  • 如果程序猿忘了调用Dispose,则还有一层保障,GC会负责对象资源的释放;

 

吐舌笑脸 性能优化建议

尽量不要手动执行垃圾回收的方法:GC.Collect()

垃圾回收的运行成本较高(涉及到了对象块的移动、遍历找到不再被使用的对象、很多状态变量的设置以及Finalize方法的调用等等),对性能影响也较大,因此我们在编写程序时,应该避免不必要的内存分配,也尽量减少或避免使用GC.Collect()来执行垃圾回收,一般GC会在最适合的时间进行垃圾回收。

而且还需要注意的一点,在执行垃圾回收的时候,所有线程都是要被挂起的(如果回收的时候,代码还在执行,那对象状态就不稳定了,也没办法回收了)。

推荐Dispose代替Finalize

如果你了解GC内存管理以及Finalize的原理,可以同时使用Dispose和Finalize双保险,否则尽量使用Dispose。

选择合适的垃圾回收机制:工作站模式、服务器模式

  题目答案解析:

1. 简述一下一个引用对象的生命周期?

  • new创建对象并分配内存
  • 对象初始化
  • 对象操作、使用
  • 资源清理(非托管资源)
  • GC垃圾回收

2. 创建下面对象实例,需要申请多少内存空间?

public class User
{
    public int Age { get; set; }
    public string Name { get; set; }

    public string _Name = "123" + "abc";
    public List<string> _Names;
}

40字节内存空间,详细分析文章中给出了。

3. 什么是垃圾?

一个变量如果在其生存期内的某一时刻已经不再被引用,那么,这个对象就有可能成为垃圾

4. GC是什么,简述一下GC的工作方式?

GC是垃圾回收(Garbage Collect)的缩写,是.NET核心机制的重要部分。她的基本工作原理就是遍历托管堆中的对象,标记哪些被使用对象(哪些没人使用的就是所谓的垃圾),然后把可达对象转移到一个连续的地址空间(也叫压缩),其余的所有没用的对象内存被回收掉。

5. GC进行垃圾回收时的主要流程是?

① 标记:先假设所有对象都是垃圾,根据应用程序根Root遍历堆上的每一个引用对象,生成可达对象图,对于还在使用的对象(可达对象)进行标记(其实就是在对象同步索引块中开启一个标示位)。

② 清除:针对所有不可达对象进行清除操作,针对普通对象直接回收内存,而对于实现了终结器的对象(实现了析构函数的对象)需要单独回收处理。清除之后,内存就会变得不连续了,就是步骤3的工作了。

③ 压缩:把剩下的对象转移到一个连续的内存,因为这些对象地址变了,还需要把那些Root跟指针的地址修改为移动后的新地址。

6. GC在哪些情况下回进行回收工作?

  • 内存不足溢出时(0代对象充满时)
  • Windwos报告内存不足时,CLR会强制执行垃圾回收
  • CLR卸载AppDomian,GC回收所有
  • 调用GC.Collect
  • 其他情况,如主机拒绝分配内存,物理内存不足,超出短期存活代的存段门限

7. using() 语法是如何确保对象资源被释放的?如果内部出现异常依然会释放资源吗?

using() 只是一种语法形式,其本质还是try…finally的结构,可以保证Dispose始终会被执行。

8. 解释一下C#里的析构函数?为什么有些编程建议里不推荐使用析构函数呢?

C#里的析构函数其实就是终结器Finalize,因为长得像C++里的析构函数而已。

有些编程建议里不推荐使用析构函数要原因在于:第一是Finalize本身性能并不好;其次很多人搞不清楚Finalize的原理,可能会滥用,导致内存泄露,因此就干脆别用了

9. Finalize() 和 Dispose() 之间的区别?

Finalize() 和 Dispose()都是.NET中提供释放非托管资源的方式,他们的主要区别在于执行者和执行时间不同:

  • finalize由垃圾回收器调用;dispose由对象调用。
  • finalize无需担心因为没有调用finalize而使非托管资源得不到释放,而dispose必须手动调用。
  • finalize不能保证立即释放非托管资源,Finalizer被执行的时间是在对象不再被引用后的某个不确定的时间;而dispose一调用便释放非托管资源。
  • 只有class类型才能重写finalize,而结构不能;类和结构都能实现IDispose。

另外一个重点区别就是终结器会导致对象复活一次,也就说会被GC回收两次才最终完成回收工作,这也是有些人不建议开发人员使用终结器的主要原因。

10. Dispose和Finalize方法在何时被调用?

  • Dispose一调用便释放非托管资源;
  • Finalize不能保证立即释放非托管资源,Finalizer被执行的时间是在对象不再被引用后的某个不确定的时间;

11. .NET中的托管堆中是否可能出现内存泄露的现象?

是的,可能会。比如:

  • 不正确的使用静态字段,导致大量数据无法被GC释放;
  • 没有正确执行Dispose(),非托管资源没有得到释放;
  • 不正确的使用终结器Finalize(),导致无法正常释放资源;
  • 其他不正确的引用,导致大量托管对象无法被GC释放;

12. 在托管堆上创建新对象有哪几种常见方式?

  • new一个对象;
  • 字符串赋值,如string s1=”abc”;
  • 值类型装箱;

网友评论

登录后评论
0/500
评论
莫问今朝乄
+ 关注