[C#基础知识之]详解C#中堆和栈的区别

线程堆栈：简称栈 Stack
托管堆： 简称堆 Heap

使用.Net框架开发程序的时候，我们无需关心内存分配问题，因为有GC这个大管家给我们料理一切。如果我们写出如下两段代码：
代码段1：

public  int AddFive( int pValue)
           {
                 int result;
                 result = pValue +  5;
                 return result;
           }

代码段2：

public  class MyInt
           {         
              public  int MyValue;
           }

           public MyInt AddFive( int pValue)
           {
                 MyInt result =  new MyInt();
                 result.MyValue = pValue +  5;
                 return result;
           }

 

问题1：你知道代码段1在执行的时候，pValue和result在内存中是如何存放，生命周期又如何？代码段2呢？
要想释疑以上问题，我们就应该对.Net下的栈(Stack)和托管堆(Heap)（简称堆）有个清楚认识，本立而道生。如果你想提高程序性能，理解栈和堆，必须的！
本文就从栈和堆，类型变量展开，对我们写的程序进行庖丁解牛。
C#程序在CLR上运行的时候，内存从逻辑上划分两大块：栈，堆。这俩基本元素组成我们C#程序的运行环境。

一，栈 vs 堆：区别？

        栈通常保存着我们代码执行的步骤，如在代码段1中 AddFive()方法，int pValue变量，int result变量等等。而堆上存放的则多是对象，数据等。（译者注:忽略编译器优化）我们可以把栈想象成一个接着一个叠放在一起的盒子。当我们使用的时候，每次从最顶部取走一个盒子。栈也是如此，当一个方法（或类型）被调用完成的时候，就从栈顶取走（called a Frame，译注：调用帧），接着下一个。堆则不然，像是一个仓库，储存着我们使用的各种对象等信息，跟栈不同的是他们被调用完毕不会立即被清理掉。

如图1，栈与堆示意图

(图1)

栈内存无需我们管理，也不受GC管理。当栈顶元素使用完毕，立马释放。而堆则需要GC(Garbage collection:垃圾收集器)清理。

二，什么元素被分配到栈？什么被分配到堆？

当我们程序执行的时候，在栈和堆中分配有四种主要的类型：值类型，引用类型，指针，指令。

值类型：
在C#中，继承自System.ValueType的类型被称为值类型，主要有以下几种（CLR2.0中支持类型有增加）：
    * bool
    * byte
    * char
    * decimal
    * double
    * enum
    * float
    * int
    * long
    * sbyte
    * short
    * struct
    * uint
    * ulong
    * ushort

引用类型：
以下是引用类型，继承自System.Object：
    * class
    * interface
    * delegate
    * object
    * string

指针：
在内存区中，指向一个类型的引用，通常被称为“指针”，它是受CLR( Common Language Runtime:公共语言运行时)管理，我们不能显示使用。需要注意的是，一个类型的引用即指针跟引用类型是两个完全不同的概念。指针在内存中占一块内存区，它本身只代表一个内存地址（或者null），它所指向的另一块内存区才是我们真正的数据或者类型。如图2：

(图2)

指令：
后文对指令再做介绍。

三，如何分配？
我们先看一下两个观点：
观点1，引用类型总是被分配在堆上。（正确？）
观点2，值类型和指针总是分配在被定义的地方，他们不一定被分配到栈上。（这个理解起来有点难度，需要慢慢来）

上文提及的栈(Stack)，在程序运行的时候，每个线程(Thread)都会维护一个自己的专属线程堆栈。
当一个方法被调用的时候，主线程开始在所属程序集的元数据中，查找被调用方法，然后通过JIT即时编译并把结果（一般是本地CPU指令）放在栈顶。CPU通过总线从栈顶取指令，驱动程序以执行下去。

下面我们以实例来详谈。

还是我们开篇所列的代码段1：

   public  int AddFive( int pValue)
           {
                 int result;
                 result = pValue +  5;
                 return result;
           }

       

当AddFive方法开始执行的时候，方法参数（parameters）则在栈上分配。如图3：

(图3)

注意：方法并不在栈中存活，图示仅供参考。
接着，指令指向AddFive方法内部，如果该方法是第一次执行，首先要进行JIT即时编译。如图4：

(图4)

当方法内部开始执行的时候，变量result被分配在栈上，如图5：

(图5)

方法执行完毕，而且方法返回后，如图6所示：

(图6)

在方法执行完毕返回后，栈上的区域被清理。如图7：

(图7)

以上看出，一个值类型变量，一般会分配在栈上。那观点2中所述又做何理解？“值类型和指针总是分配在被定义的地方，他们不一定被分配到栈上”。
原因就是如果一个值类型被声明在一个方法体外并且在一个引用类型中，那它就会在堆上进行分配。
还是代码段2：

public  class MyInt
           {         
              public  int MyValue;
           }

           public MyInt AddFive( int pValue)
           {
                 MyInt result =  new MyInt();
                 result.MyValue = pValue +  5;
                 return result;
           }

 

当线程开始执行AddFive方法的时候，参数被分配到栈上，如图8所示：

（图8）
由于MyInt是一个引用类型，所以它被分配到堆上，并且在栈中生成一个指针(result)，如图9：

（图9）
AddFive方法执行完毕时的情况如图10：

(图10)

栈上内存被清理，堆中依然存在，如图11：

 
(图11)

当程序需要更多的堆空间时，GC需要进行垃圾清理工作，暂停所有线程，找出所有不可达到对象，即无被引用的对象，进行清理。并通知栈中的指针重新指向地址排序后的对象。现在我们应该知道，了解栈和堆，对我们开发出高性能程序的重要性。当我们使用引用类型的时候，一般是对指针进行的操作而非引用类型对象本身。但是值类型则操作其本身。
接下来，我们用例子说明这一点。

例1：

public  int ReturnValue()
           {
                 int x =  new  int();
                 x =  3;
                 int y =  new  int();
                 y = x;      
                 y =  4;         
                 return x;
           }

执行结果为3,稍作修改：

例2：

public  class MyInt
           {
                 public  int MyValue;
           }

           public  int ReturnValue2()
           {
                 MyInt x =  new MyInt();
                 x.MyValue =  3;
                 MyInt y =  new MyInt();
                 y = x;                 
                 y.MyValue =  4;              
                 return x.MyValue;
           }

执行结果为4。

我们来分析下原因，其实例1的跟以下代码所起效用一样：

public  int ReturnValue()
           {
                 int x =  3;
                 int y = x;    
                 y =  4;
                 return x;
           }

         
如图12所示，在栈上x和y分别占用一块内存区，互不干扰。

（图12）

而例2，与以下代码所起效用一样：

    public  int ReturnValue2()
           {
                 MyInt x;
                 x.MyValue =  3;
                 MyInt y;
                 y = x;                
                 y.MyValue =  4;
                 return x.MyValue;
           }

 

如图13所示，

 
(图13)
栈上的指针x和y指向堆上同一个区域，修改其一必会改变堆上的数据。

总结：

理解堆与栈对于理解.NET中的内存管理、垃圾回收、错误和异常、调试与日志有很大的帮助。垃圾回收的机制使程序员从复杂的内存管理中解脱出来，虽然绝大多数的C#程序并不需要程序员手动管理内存，但这并不代表程序员就无需了解分配的对象是如何被回收的，在一些特殊的场合仍需要程序员手动进行内存管理。

在32位的处理器上，每个进程的虚拟内存为4GB，.NET会在这4GB的内存块中开辟出3块内存，分别作为栈、托管堆、和非托管堆

堆（heap）:

堆是从下往上分配，所以已用的空间在自由空间下面，C#中所有引用类型的对象分配在托管堆上，托管堆在内存上是连续分配的，并且内存对象的释放受垃圾收集机制的管理，效率相对于栈来说要低的多。

栈（stack）:

栈是自上向下进行填充，即由高内存地址指向低内存地址，并且内存分配是连续的，C#中所有的值类型和引用类型的引用都分配在栈上，栈根据后进先出的原则，依次对分配和释放内存对象。

对象内存的分配与销毁：

当一个类的实例对象创建的时候，这个对象的不同成员按类别被分配到了不同的内存区域，值类型和引用类型的指针被分配到了栈上，引用类型的实例对象被分配到了托管堆上，静态成员被分配到了全局数据区。此时栈上的指针会指向堆上的对象。当对象使用完以后，引用和实际对象的联系就会断开，从而从而使对象冬眠。因为栈具有自我维护性，它的内存管理可以通过操作系统来完成，而此时堆上的冬眠对象就需要通过垃圾回收器（GC）使用一定的算法来进行回收，释放对象所占据的内存。

C#中的深拷贝与浅拷贝

深拷贝：又称深度克隆，它完全是新对象的产生，不仅复制所有的非静态值类型成员，而且复制所有引用类型成员的实际对象。（即栈上和堆上的成员均进行复制）

浅拷贝：又称影子克隆，只复制原始对象中的所有的非静态的值类型成员和所有引用类型成员的引用，就是说，原始对象和新对象共享所有引用类型成员的对象实例。(即只复制栈上的成员)

注：不管是深拷贝还是浅拷贝，都不会复制全局数据区的成员，因为全局数据区的成员是静态成员，它属于某一个类，并不属于类的实例对象，因此无法复制。

C#中的深拷贝可以通过实现ICloneable接口来实现，但是在不是必须实现ICloneable接口的情况下，应避免类型继承ICloneable接口。因为这样做将强制所有的子类必须实现ICloneable接口，否则子类的新成员将不能被类型的深拷贝所覆盖。