内存管理的噩梦：泄漏与溢出

内存模型

Heap（There）：堆区，由开发人员申请内存，在垃圾回收器的控制下工作。

引述与拓展阅读：

1.理论与实践中的C#内存模型（上）:

https://docs.microsoft.com/zh-cn/archive/msdn-magazine/2012/december/csharp-the-csharp-memory-model-in-theory-and-practice

2.理论与实践中的C#内存模型（下）:

https://docs.microsoft.com/zh-cn/archive/msdn-magazine/2013/january/csharp-the-csharp-memory-model-in-theory-and-practice-part-2

内存管理

在了解内存管理之前，我们先来了解一下最常见的两大关于内存的问题：内存溢出和内存泄漏

内存溢出（out of memory）：通俗理解就是内存不够了，指程序要求的内存超出了系统所能分配的范围，通常在运行大型软件或3A游戏时，软件或3A游戏所需要的内存远远超出了主机内安装的内存所能承受的大小，就叫内存溢出。比如，你申请了一个int类型，但给了他一个long才能存放的数，那就会发生内存溢出，或者你创建一个大对象，而堆内放不下这个对象，这也是内存溢出

内存泄漏（memory leak）:指程序中已动态分配的堆内存由于某种原因，程序未释放或者无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。单次内存泄漏的危害可以忽略，但是很多内存泄漏的堆积造成的后果不可估量，无论多少内存，迟早都会被占用干净。

二者关系：

• 垃圾收集器(GC)是.Net框架的一部分，它为.Net应用程序分配和释放内存

• 当一个新进程启动时，运行时会为该进程保留一个称为托管堆的地址空间区域

• 对象在堆中一个接一个地连续分配

• 内存分配是一个非常快的过程，因为它只是像指针添加一个值

• 除托管堆外，应用程序总是会消耗一些不受GC管理的所谓非托管的内存

  通常,.NET公共语言运行时（CLR）本身、应用程序使用的动态库、图形缓冲区等都需要非托管内存

• 释放内存的过程称为垃圾回收

• 当GC执行收集时，它只释放应用程序不再使用的对象（例，方法中的局部变量只能在方法执行期间访问，之后不再需要该变量了）

• 为确定对象是否被使用，GC检查应用程序的根--对应用程序全局的强引用。通常，这些是全局和静态对象指针，局部变量和CPU寄存器。

• 对于每个活动根，GC构建一个图，其中包含从这些根可到达的所有对象。

• 如果一个对象不可达，GC认为它不再被使用，并从堆中移除该对象（释放该对象所占用的内存）

• 对象被移除后，GC会在内存中压缩可达对象

• 由于性能原因，大型对象（大于85KB）存储在托管堆的一个单独段中，称为大型对象堆（LOH)

• LOH中的幸存对象未压缩。这意味着LOH会随时间的推移变得支离破碎。

  在.NET Framework4.5.1后，可以在完全垃圾回收期强制GC压缩LOH

总结

遵从上述的世代规则，耗时的压缩过程仅仅在绝对必要时候才发生。

注：如果在Gen2中看到较高比例的内存，则表明内存被占用很长时间，并且可能会有内存问题，需要借助内存分析工具

据上述所属，大于85KB对象会被分配到一个特殊的"大对象堆"（LOH）。由于复制它们会有大块的内存开销，所以它们基本上不会被压缩。当发生GC时，未使用的LOH对象的地址范围将记录在空闲空间分配表中。

当分配一个新对象时，会检查这个可用空间表是否有足够大的地址范围来保存该对象。如果存在，则在此处分配对象，如果不存在，则在下一个可用空间中分配。

因为对象不太可能是空地址范围的确切大小，所以几乎总是会在对象之间留下小块内存，从而导致大量碎片，如果这些块小于85KB，则根本不可能重用。因此，随着分配需求越来越高，即使碎片空间可用，也会保留新的段。

此外，当需要分配大对象时，.NET倾向于将对象附加到末尾，而不是运行昂贵的Gen2 GC.这堆性能有好处，但也时导致内存碎片的主要原因。

.NET通过GC提供两种模式来解决性能和堆效率之间的权衡。分为：工作站模式和服务器模式。

工作站模式：为用户提供最大的响应速度，并减少GC导致的暂停。可作为"并发"或"非并发"运行，指的是GC运行的线程。默认为并发，它为GC使用单独的线程，因此应用程序可以在GC运行时继续执行。

服务器模式：为服务器环境提供最大的吞吐量、可拓展性和性能。服务器模式下的段大小和生成阈值通常比工作站模式大得多，这反映堆服务器的更高要求。其在多个线程上并行运行垃圾收集，为每个逻辑处理器分配单独的SOH（小对象）和LOH，以防止线程互相干扰。

.NET框架提供了交叉引用机制，因此对象仍然可以跨堆相互引用。但是，由于应用程序响应能力不是服务器模式的直接目标，因而所有应用程序线程都在GC期间暂停。

弱对象引用GC根的替代来源，让开发者可以保留对象，同时允许在GC需要时收集它们。它们时代码性能和内存效率的这种。创建对象需要CPU时间，但保持加载需要内存。

弱引用特别适合大型数据结构。例如，假设有个应用程序允许用户浏览大型数据结构，其中一些它们可能会返回，您可以将任何对用户浏览过的对数据结构的强引用转换为弱引用。如果用户返回这些数据结构，他们是可用的。如果不返回，GC可以在需要的时候回收它。

.NET使用GCHandle的结构来跟踪堆对象。GCHandle可用于在托管域

引述与拓展阅读：

1.托管代码：https://docs.microsoft.com/zh-cn/dotnet/standard/managed-code

2.垃圾回收：https://docs.microsoft.com/zh-cn/dotnet/standard/garbage-collection/fundamentals

3.GC根：https://www.jetbrains.com/help/dotmemory/Analyzing_GC_Roots.html

4.GC工作模式：https://devblogs.microsoft.com/premier-developer/understanding-different-gc-modes-with-concurrency-visualizer/

5.LOH:https://docs.microsoft.com/zh-cn/dotnet/standard/garbage-collection/large-object-heap

GC工作原理

  IL_0000: newobj instance void Customer::.ctor()

• 计算新建对象所需的内存总数

• 检查托管堆，确保有足够的空间来存放新建的对象

  如果空间足够，调用类型的构造函数，将对象存放在NextObjPtr指向的内存地址

  如果空间不够，就会执行一次垃圾回收来清理托管堆（如果依然不够，报出内存溢出异常)

• 最后，移动NextObjPtr指向托管堆下一个可用地址，然后将对象引用返回给调用者

GC是如何确定一个对象不再被需要的，可以被安全销毁的呢？

这个时候就需要一个应用程序根（application root）的概念。根（root）就是一个存储位置，其中保存着对托管堆上一个对象的引用，根可以属于以下任一类别：

注：上图灰色对象则为不可达的对象

如上图，假设托管堆上有A-G七个对象，垃圾回收过程中GC会检查所有的对象是否有活动根。过程大致描述如下：

GC常见问题

最佳实践

• 托管内存泄漏：当程序拥有仍被引用但实际上未使用的对象时，由于引用关系存在，GC不会回收，它们会一直存在占着内存。例如，注册事件但从未在必要的情况下取消注册时，可能会存在这样的问题。

• 非托管内存泄漏：以某种方式分配非托管内存（GC不收集这部分）并且忘记释放它。这样的场景存在于对流、图形、文件系统或网络调用。通常通过实现Dispose释放内存。也可以使用特殊的 .NET 类（如Marshal）或使用PInvoke轻松地自己分配非托管内存

public class AnonymousClass{
  private JobQueue _jbQueue;
  private int _id;
  
  public AnonymousClass(JobQueue jobQueue){
      _jbQueue=jobQueue;
  }
  public void Foo(){
    _jobQueue.EnqueueJob(()=>{
      Logger.Log($"Executing job with Id {_id}");
      //do other stuff.
    });
  }
}

public class AnonymousClass{
  private JobQueue _jbQueue;
  private int _id;
  
  public AnonymousClass(JobQueue jobQueue){
      _jbQueue=jobQueue;
  }
  public void Foo(){
    var localId = _id;
    _jobQueue.EnqueueJob(()=>{
      Logger.Log($"Executing job with Id {localId}");
      //do other stuff.
    });
  }
}

public class MemoryClass :IDisposable{
  private IntPtr _buffer;
  public MemoryClass(){
     _buffer = Marshal.AllocaHGlobal(1000);
     //do stuff without freeing the buffer memory. 
  }
  
  public void Dispose(){
     Marshal.FreeHGlobal(_buffer);
  }
}