C#学习笔记（十四）：GC机制和弱引用

垃圾回收（GC）

垃圾回收即Garbage Collector，垃圾指的是内存中已经不会再使用的对象，通过收集释放掉这些对象占用的内存。


关于C#使用的垃圾回收算法可以点击这里查看。

析构函数

析构函数会在GC执行清楚当前对象时被调用，可以在析构函数中执行一些释放方法。

代

为了优化GC算法，微软使用了“代”的概念，介绍如下：


我们来看一个例子：

using System;

namespace Study
{
class Program
{
static void Main(string[] args)
{
Test test = new Test();

//对象会被分配到第 0 代
Console.WriteLine("test对象所在的代：" + GC.GetGeneration(test));
//回收对象, 这时 test 会被分配到第 1 代
GC.Collect();
Console.WriteLine("test对象所在的代：" + GC.GetGeneration(test));
//回收对象, 这时 test 会被分配到第 2 代
GC.Collect();
Console.WriteLine("test对象所在的代：" + GC.GetGeneration(test));
//回收对象, 最多只有3个代, 所以 test 还在第 2 代
GC.Collect();
Console.WriteLine("test对象所在的代：" + GC.GetGeneration(test));

//断开引用, 对象会被回收
test = null;
//回收对象, test 会被回收并调用析构函数
GC.Collect();

Console.Read();
}
}

public class Test
{
~Test()
{
Console.WriteLine("Test被回收了！");
}
}
}

运行结果如下：

test对象所在的代：0
test对象所在的代：1
test对象所在的代：2
test对象所在的代：2
Test被回收了！

何时GC

.Net何时执行GC在《C#高级编程》书中也只是简单的一句“垃圾回收会在运行库认为需要他时运行。”带过，总体而言，GC运行策略已经被微软进行优化过了，我们不需要过多的关心即可。

托管对象和非托管对象

在C#中，很大部分的对象都是托管对象，托管对象的释放直接由GC来处理，但也存在部分非托管对象，这些对象GC是不能对其进行自动回收的。

非托管对象

即不受运行时管理的资源对象（如窗口句柄 (HWND)、数据库连接等）。


比如：当我们使用一个System.IO.StreamReader的一个文件对象，必须显示的调用对象的Close()方法关闭它，否则会占用系统的内存和资源，而且可能会出现意想不到的错误。

Finalize

当我们声明一个析构函数时实际上编译器就会自动添加下面的代码：

~Test()
{
try{
Finalize();
}finally{
base.Finalize();
}
}

如果在派生类中不存在析造函数，却重载了基类的终结器：

protected override void Finalize()
{
}

垃圾回收时，GC找不到构造函数，会直接调用终结器。

如果没有显示释放资源时，GC时可以靠该方法进行隐式的释放资源。

Dispose

相对于重写Finalize方法，实现IDisposable接口来进行显示的释放资源是更好的一种方式。

我们只需要实现IDisposable接口即可，我们看看官网提供的常规写法：

using System;

class BaseClass : IDisposable
{
// Flag: Has Dispose already been called?
bool disposed = false;

// Public implementation of Dispose pattern callable by consumers.
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}

// Protected implementation of Dispose pattern.
protected virtual void Dispose(bool disposing)
{
if (disposed)
return;

if (disposing) {
// Free any other managed objects here.
//
}

// Free any unmanaged objects here.
//
disposed = true;
}
}

https://msdn.microsoft.com/zh-cn/library/system.idisposable(v=vs.110).aspx

https://msdn.microsoft.com/zh-cn/library/fs2xkftw(v=vs.110).aspx

弱引用

我们都知道当一个对象存在一个或多个引用时，GC是不会释放该对象的，如下：

Object obj = new Object();

这种引用称为强引用。

但是我们可以想一下，还有一种情况是对象稍后可能被使用，但不是很确定是否会使用时，就可以使用弱引用了。

弱引用可以理解为：如果一个对象只存在一个或多个弱引用而没有强引用时，则GC可以对其进行垃圾回收。

那么在C#中该如何使用弱引用呢？

WeakReference和WeakReference<T>

C#提供了两个类来实现弱引用的功能，我们只需要将对象装入该类的实例中，则可以理解为为这个对象添加了一个弱引用，下面给出帮助文档地址：

WeakReference：https://msdn.microsoft.com/zh-cn/library/system.weakreference(v=vs.110).aspx

WeakReference<T>：https://msdn.microsoft.com/zh-cn/library/gg712738(v=vs.110).aspx

我们再看一个例子：

using System;

namespace Study
{
class Program
{
static void Main(string[] args)
{
//强引用
Test test = new Test();
//弱引用 1
WeakReference weak1 = new WeakReference(test);
//弱引用 2
WeakReference<Test> weak2 = new WeakReference<Test>(test);

//存在强引用不会被回收
GC.Collect();

//注意 temp 也是一个强引用
Test temp;

Console.WriteLine("weak1: " + weak1.IsAlive + ", weak2: " + weak2.TryGetTarget(out temp));

//解除所有强引用
test = null;
temp = null;

//没有强引用会被回收
GC.Collect();

Console.WriteLine("weak1: " + weak1.IsAlive + ", weak2: " + weak2.TryGetTarget(out temp));

Console.Read();
}
}

public class Test
{
~Test()
{
Console.WriteLine("Test被回收了！");
}
}
}

结果如下：

weak1: True, weak2: True
weak1: False, weak2: False
Test被回收了！