C#垃圾回收与内存管理【转】

现在的位置: 首页 > 综合 > 正文

RSS

C#垃圾回收与内存管理【转】

2018年04月09日 ⁄ 综合 ⁄ 共 11597字 ⁄ 字号小中大 ⁄ 评论关闭

原：http://www.mikel.cn/article.asp?id=1698

你清楚.Net的垃圾回收机制吗？你能简述一下GC的工作原理吗？怎么样才能有效的管理内存呢？Using语句体内实例化的对象有什么作用？

本节的组织如下，1..Net的类型和内存分配2.GC垃圾收集器的工作原理3.什么是非托管资源4.如何有效释放对象资源。总结.现在开始我们本节的学习。

1..Net的类型和内存分配

Net中的所有类型都是（直接或间接）从
System.Object
类型派生的。

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

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

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

2.GC垃圾收集器的工作原理

上图中，当dataSet使用过期以后，我们不显示销毁对象，堆上的对象还继续存在，等待GC的回收。

垃圾收集器通过分代支持对象的年龄化是推荐的但不是必需的。一代在内存里是一个具有相对年龄的对象的单位。对象的

代号或年龄标识对象属于那个分代。在应用程序的生命周期里，越近创建的对象属于越新的代，并且比早创建的对象具有

较低的分代号。最近分代里的对象代号是0.

在new对象时，要先搜索空闲链表，找到最适合内存块，分配，调整内存块链表，合并碎片。new操作几乎可以在O(1)的时间完成，把堆顶指针加1。工作原理是：当托管堆上剩余空间不足，或者Generator
0
的空间已满的时候GC运行，开始回收内存。垃圾回收的开始，GC对堆内存的压缩调整，对象集中到顶部。GC在扫描垃圾的时候会占用一定的CPU时间片的，最初的GC算法真的是扫描整个堆，效率低。现在的GC把堆中的对象分成3代，最近
进入堆的是第0代(generation 0), 其次是generation 1, generation2.
第一次GC只扫描第0代。如果回收的空间足够当前使用就不必扫描其它generation的对象。所以，GC创建对象的效率比C++高效，不需要扫描全部堆空间。它通过扫描策略，再加上内存管理策略带来的性能提升，足以补偿GC所占用的CPU时间。

3.什么是非托管资源

　　常见的非托管资源就是包装操作系统资源的对象，例如文件，窗口或网络连接，对于这类资源虽然垃圾回收器可以跟踪封装非托管资源的对象的生存期，但它知道如何清理这些资源。好在.net
Framework提供的Finalize()方法，它允许在垃圾回收器回收该类资源前，适当的清理非托管资源。这里列举几种常见的非托管资源：画笔、流对象、组件对象等等资源（Object,OdbcDataReader,OleDBDataReader,Pen,Regex,Socket,StreamWriter,ApplicationContext,Brush,

Component,ComponentDesigner,Container,Context,Cursor,FileStream,

Font,Icon,Image,Matrix,Timer,Tooltip）。（参考MSDN）

4.如何有效释放非托管资源。

GC无法管理非托管资源，那么如何释放非托管资源呢？.Net提供了两种方式：

（1）析构函数：垃圾收集器回收非托管对象的资源时，会调用对象的终结方法Finalize(),进行资源的清理工作，但是由于GC工作规则的限制，GC调用对象的Finalize方法，第一次不会释放资源，第二次调用之后才删除对象。

（2）继承IDisposable
接口,实现Dispose()方法，IDisposable接口定义了一个模式(具有语言级的支持)，为释放未托管的资源提供了确定的机制，并避免产生析构函数固有的与垃圾收集器相关的问题。

为了更好的理解垃圾回收机制，我特地写了部分代码，里面添加了详细的注释。定义单个类FrankClassWithDispose（继承接口IDisposable
）
、FrankClassNoFinalize（没终结器）
、FrankClassWithDestructor（定义了析构函数）。

具体代码如下：

using
System;

2

using
System.Collections.Generic;

3

using
System.Text;

4

using
System.Data;

5

using
System.Data.Odbc;

6

using
System.Drawing;

7

//
Coded By Frank Xu Lei 18/2/2009

8

//
Study the .NET Memory Management

9

//
Garbage Collector 垃圾收集器。可以根据策略在需要的时候回收托管资源，

10

//
但是GC不知道如何管理非托管资源。如网络连接、数据库连接、画笔、组件等

11

//
两个机制来解决非托管资源的释放问题。析构函数、IDispose接口

12

//
COM引用计数

13

//
C++手动管理，New Delete

14

//
VB自动管理

15

namespace
MemoryManagement

16

{

17

//
继承接口IDisposable，实现Dispose方法，可以释放FrankClassDispose的实例资源

18

public

class
FrankClassWithDispose : IDisposable

19

{

20

private
OdbcConnection _odbcConnection
=

null
;

21

//
构造函数

23

public
FrankClassWithDispose()

24

{

25

if
(_odbcConnection
==

null
)

26

_odbcConnection
=

new
OdbcConnection();

27

Console.WriteLine(
"
FrankClassWithDispose has been created

"
);

28

}

29

//
测试方法

30

public

void
DoSomething()

31

{

32

///
/code here to do something

34

return
;

35

}

36

//
实现Dispose，释放本类使用的资源

37

public

void
Dispose()

38

{

39

if
(_odbcConnection
!=

null
)

40

_odbcConnection.Dispose();

41

Console.WriteLine(
"
FrankClassWithDispose has been disposed

"
);

42

}

43

}

44

//
没有实现Finalize,等着GC回收FrankClassFinalize的实例资源，GC运行时候直接回收

45

public

class
FrankClassNoFinalize

46

{

47

private
OdbcConnection _odbcConnection
=

null
;

48

//
构造函数

49

public
FrankClassNoFinalize()

50

{

51

if
(_odbcConnection
==

null
)

52

_odbcConnection
=

new
OdbcConnection();

53

Console.WriteLine(
"
FrankClassNoFinalize has been created

"
);

54

}

55

//
测试方法

56

public

void
DoSomething()

57

{

58

//
GC.Collect();

60

///
/code here to do something

61

return
;

62

}

63

}

64

//
实现析构函数，编译为Finalize方法，调用对象的析构函数

65

//
GC运行时，两次调用，第一次没释放资源，第二次才释放

66

//
FrankClassDestructor的实例资源

67

//
CLR使用独立的线程来执行对象的Finalize方法,频繁调用会使性能下降

68

public

class
FrankClassWithDestructor

69

{

70

private
OdbcConnection _odbcConnection
=

null
;

71

//
构造函数

72

public
FrankClassWithDestructor()

73

{

74

if
(_odbcConnection
==

null
)

75

_odbcConnection
=

new
OdbcConnection();

76

Console.WriteLine(
"
FrankClassWithDestructor has been created

"
);

77

}

78

//
测试方法

79

public

void
DoSomething()

80

{

81

///
/code here to do something

82

return
;

84

}

85

//
析构函数,释放未托管资源

86

~
FrankClassWithDestructor()

87

{

88

if
(_odbcConnection
!=

null
)

89

_odbcConnection.Dispose();

90

Console.WriteLine(
"
FrankClassWithDestructor has been disposed

"
);

91

}

92

}

93

}

94

其中使用了非托管的对象OdbcConnection
的实例。建立的客户端进行了简单的测试。客户端代码如下：

using
System;

2

using
System.Collections.Generic;

3

using
System.Text;

4

using
System.Data;

5

using
MemoryManagement;

6

//
Coded By Frank Xu Lei 18/2/2009

7

//
Study the .NET Memory Management

8

//
Test The Unmanaged Objects Reclaimed.

9

//
针对非托管代码的测试，比较

10

//
托管代码，GC可以更具策略自己回收，也可以实现IDisposable，调用Dispose()方法，主动释放。

11

namespace
MemoryManagementClient

12

{

13

class
Program

14

{

15

static

void
Main(
string
[] args)

16

{

17

///////////////////////////////////////
//(1)
//////////////////////////////////////////
//

19

//
调用Dispose()方法，主动释放。资源，灵活

20

FrankClassWithDispose _frankClassWithDispose
=

null
;

21

try

22

{

23

_frankClassWithDispose
=

new
FrankClassWithDispose();

24

_frankClassWithDispose.DoSomething();

25

}

27

finally

28

{

29

if
(_frankClassWithDispose
!=
null
)

30

_frankClassWithDispose.Dispose();

31

//
Console.WriteLine("FrankClassWithDispose实例已经被释放

");

32

}

33

///////////////////////////////////////
//(2)
/////////////////////////////////////////////
/

35

//
可以使用Using语句创建非托管对象,方法执行结束前，会调用

36

using
(FrankClassWithDispose _frankClassWithDispose2
=

new
FrankClassWithDispose())

37

{

38

//
_frankClassWithDispose2.DoSomething();

39

}

40

///////////////////////////////////////
//(3)
//////////////////////////////////////////
//

42

//
垃圾收集器运行的时候，一次就释放资源

43

FrankClassNoFinalize _frankClassNoFinalize
=

new
FrankClassNoFinalize();

44

_frankClassNoFinalize.DoSomething();

45

//////////////////////////////////////////
(4)
/////////////////////////////////////////////
/

47

//
垃圾收集器运行的时候,两次才能够释放资源

48

FrankClassWithDestructor _frankClassWithDestructor
=

new
FrankClassWithDestructor();

49

_frankClassWithDestructor.DoSomething();

50

//////////////////////////////////////////
/(5)
/////////////////////////////////////////////

51

//
不能使用Using语句来创建对象，因为其没实现IDispose接口

52

//
using (FrankClassWithDestructor _frankClassWithDestructor2 = new FrankClassWithDestructor())

53

//
{

54

//
_frankClassWithDestructor2.DoSomething();

55

//
}

56

////////////////////////////////////////////////////////////////////////////////////
//

58

//
For Debug

59

Console.WriteLine(
"
Press any key to continue

"
);

60

Console.ReadLine();

61

}

64

}

65

}

66

有些时候资源必须在特定时间释放，类可以实现执行资源管理和清除任务方法IDisposable.Dispose的接口IDisposable。
如果调用者需要调用Dispose方法清理对象，类作为契约的一部分必须实现Dispose方法。垃圾收集器默认情况下不会调用
Dispose方法；然而，实现Dispose方法可以调用GC里的方法去规范垃圾收器的终结行为。

值得一提的是：调用Dispose()方法，主动释放资源，灵活，可以使用Using语句创建非托管对象,方法执行结束前，会调用
Dispose()方法释放资源，
这两端代码的效果是一样的，可以查看编译后IL。

.
try

2

{

3

IL_0003: nop

4

IL_0004: newobj instance
void
[MemoryManagement]MemoryManagement.FrankClassWithDispose::.ctor()

5

IL_0009: stloc.
0

6

IL_000a: ldloc.
0

7

IL_000b: callvirt instance
void
[MemoryManagement]MemoryManagement.FrankClassWithDispose::DoSomething()

8

IL_0010: nop

9

IL_0011: nop

10

IL_0012: leave.s IL_0028

11

}

//
end .try

12

finally

13

{

14

IL_0014: nop

15

IL_0015: ldloc.
0

16

IL_0016: ldnull

17

IL_0017: ceq

18

IL_0019: stloc.s CS$
4
$
0000

19

IL_001b: ldloc.s CS$
4
$
0000

20

IL_001d: brtrue.s IL_0026

21

IL_001f: ldloc.
0

22

IL_0020: callvirt instance
void
[MemoryManagement]MemoryManagement.FrankClassWithDispose::Dispose()

23

IL_0025: nop

24

IL_0026: nop

25

IL_0027: endfinally

26

}

//
end handler

27

IL_0028: nop

28

IL_0029: newobj instance
void
[MemoryManagement]MemoryManagement.FrankClassWithDispose::.ctor()

29

IL_002e: stloc.
1

30

.
try

31

{

32

IL_002f: nop

33

IL_0030: nop

34

IL_0031: leave.s IL_0045

35

}

//
end .try

36

finally

37

{

38

IL_0033: ldloc.
1

39

IL_0034: ldnull

40

IL_0035: ceq

41

IL_0037: stloc.s CS$
4
$
0000

42

IL_0039: ldloc.s CS$
4
$
0000

43

IL_003b: brtrue.s IL_0044

44

IL_003d: ldloc.
1

45

IL_003e: callvirt instance
void
[mscorlib]System.IDisposable::Dispose()

46

IL_0043: nop

47

IL_0044: endfinally

48

}

//
end handler

49

Using
语句有同样的效果，来实现非托管对象资源的释放。这点在面试中也会经常遇到，Using关键字的用法有哪几种等等类似的问题。基本理想的答案都是除了引用命名空间，和命名空间设置别名外，就是这个用法实现如try
finally块一样作用的对非托管对象资源的回收。只是一种简便的写法。

当你用Dispose方法释放未托管对象的时候，应该调用GC.SuppressFinalize。如果对象正在终结队列(finalization
queue),GC.SuppressFinalize会阻止GC调用Finalize方法。因为Finalize方法的调用会牺牲部分性能。如果你的Dispose方法已经对委托管资源作了清理，就没必要让GC再调用对象的Finalize方法(MSDN)。附上MSDN的代码，

大家可以
参考.

public

class
BaseResource: IDisposable

{

//
指向外部非托管资源

private
IntPtr handle;

//
此类使用的其它托管资源.

private
Component Components;

//
跟踪是否调用.Dispose方法，标识位，控制垃圾收集器的行为

private

bool
disposed
=

false
;

//
构造函数

public
BaseResource()

{

//
Insert appropriate constructor code here.

}

//
实现接口IDisposable.

//
不能声明为虚方法virtual.

//
子类不能重写这个方法.

public

void
Dispose()

{

Dispose(
true
);

//
离开终结队列Finalization queue

//
设置对象的阻止终结器代码

GC.SuppressFinalize(
this
);

}

//
Dispose(bool disposing) 执行分两种不同的情况.

//
如果disposing 等于 true, 方法已经被调用

//
或者间接被用户代码调用. 托管和非托管的代码都能被释放

//
如果disposing 等于false, 方法已经被终结器 finalizer 从内部调用过，

//
你就不能在引用其他对象，只有非托管资源可以被释放。

protected

virtual

void
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
"
)]

private

extern

static
Boolean CloseHandle(IntPtr handle);

//
使用C# 析构函数来实现终结器代码

//
这个只在Dispose方法没被调用的前提下，才能调用执行。

//
如果你给基类终结的机会.

//
不要给子类提供析构函数.

~
BaseResource()

{

//
不要重复创建清理的代码.

//
基于可靠性和可维护性考虑，调用Dispose(false) 是最佳的方式

Dispose(
false
);

}

//
允许你多次调用Dispose方法,

//
但是会抛出异常如果对象已经释放。

//
不论你什么时间处理对象都会核查对象的是否释放,

//
check to see if it has been disposed.

public

void
DoSomething()

{

if
(
this
.disposed)

{

throw

new
ObjectDisposedException();

}

对于需要调用Close方法比Dispose方法更加自然的类型，可以在基类增加一个Close方法。

Close方法无参调用执行恰当清理工作的Dispose方法。

下面的例子演示了Close方法。

//
不要设置方法为virtual.

//
继承类不允许重写这个方法

public

void
Close()

{

//
无参数调用Dispose参数.

Dispose();

}

public

static

void
Main()

{

//
Insert code here to create

//
and use a BaseResource object.

}

DemoCodes/Files/frank_xl/MemoryManagement2008.zip

【上篇】IE条件注释…. (||)【转】
【下篇】jQuery 技术专家Karl Swedberg 谈 jQuery【转】

作者: DannyManson

该日志由 DannyManson 于6年前发表在综合分类下，最后更新于 2018年04月09日.
转载请注明: C#垃圾回收与内存管理【转】 | 学步园 +复制链接

抱歉!评论已关闭.

学步园

C#垃圾回收与内存管理【转】

作者: DannyManson

书签

最新文章New

本站推荐

返回首页