## 引言

今天同事问了我一个问题，`System.Windows.Forms.Timer`是前台线程还是后台线程，我当时想的是它是跟着UI线程一起结束的，应该是前台线程吧？

我确实没有仔细研究过他们的异同，所以带着这个疑问探究一下`System.Windows.Forms.Timer`。


## System.Windows.Forms.Timer

### 机制
`System.Windows.Forms.Timer` 是 `Windows Forms` 中的一个定时器控件，它的工作原理基于 `Windows` 消息循环机制。

这个Windows消息循环机制说简单一点就是它有一个**消息队列**，一个`while(true)` **循环结构**，一个**窗口消息处理函数**，消息队列保存了在应用程序或系统中发生的各种事件和消息，如鼠标点击、键盘输入、窗口重绘等。循环结构消息队列中不断取出消息。然后通过窗口消息处理函数分发给相应的窗口过程进行处理。

而 `System.Windows.Forms.Timer` 的事件触发机制如下：

- Timer 控件利用 Windows 的消息机制来触发 Tick 事件。在定时器启动后，它会在每个 Interval 时间间隔后，将一个 `WM_TIMER` 消息放入应用程序的消息队列。
- `WM_TIMER` 是一个定时器消息，它是由 Windows 消息循环派发的。
- 当应用程序处理消息循环时，当收到` WM_TIMER` 消息，就会触发 Timer 的 Tick 事件。


### 源码解析

来通过源码看一下它的触发机制（这里节选了部分重要函数），它的源码还是比较简单的，仅有300多行。我们先来看一下 `System.Windows.Forms.Timer` 的调用，一般是这样使用：

```csharp
using System.Windows.Forms;

// 创建一个 Timer 实例
Timer timer = new Timer();
// 设置触发间隔时间（以毫秒为单位）
timer.Interval = 1000; // 1000 毫秒 = 1 秒
// 绑定 Tick 事件处理程序
timer.Tick += Timer_Tick;
// 启动 Timer
timer.Start();

// Tick 事件处理程序
private void Timer_Tick(object sender, EventArgs e)
{
    // 定时触发的操作
}

```
我们就按照上面的步骤来剖析一下源码：

**第一步：创建实例**

这一步并无特别，无参构造默认创建的实例默认 `Interval` 值为100。含参构造创建时会将该实例添加到参数容器中。

![image.png](https://niuery.com/static/img/0ee366f8701a3ea89ec0b096bb46611f.image.png)

**第二步：注册Tick**

 `System.Windows.Forms.Timer` 声明了一个 `onTimer` 委托，注册 `Tick` 是将注册的方法赋值给 `onTimer` 委托。

![image.png](https://niuery.com/static/img/abcf09235a71e648591972948c9a8f9f.image.png)

**第三步：启动Timer**

可以看到Timer的 `Start()` 和 `Stop()`，实际都是给 `Enabled` 赋值，所以我们可以着重看一下 `Enabled` 属性的 Setter 方法。

![image.png](https://niuery.com/static/img/1a5b5660d83d05ade1c13a7440e7b485.image.png)

**第四步：TimerNativeWindow 启动**

可以看到`System.Windows.Forms.Timer` 持有一个 **TimerNativeWindow** 类型的私有变量，是由这个私有变量启动的Timer.
![image.png](https://niuery.com/static/img/e28476f811f783864c8dfce162359567.image.png)

**第五步：TimerNativeWindow 实现**

上一步中，可以看到当 `Enable` 置为 `true` 时，一个 **TimerNativeWindow** 类型的私有变量调用了 `StartTimer(interval)` 方法，那么来看一下这个 `TimerNativeWindow` 的实现。

如下图，可以看到当 `TimerNativeWindow` 调用 `StartTimer()`时，调用了 `SafeNativeMethods.SetTimer` 方法，传入了当前Timer的窗口句柄，还有加1后的 `_timerID` ，以及间隔 `Interval`。

该方法的作用就是向Windows消息循环机制的消息队列中插入一条Timer消息。

![image.png](https://niuery.com/static/img/ee6061b4a00d9ed2e0901078b7de2c67.image.png)

上图中，我除了框出了`StartTimer()`方法，还框出了 `WndProc(ref Message m)` 方法。这个方法就很重要了。这个就是上面所说的 Windows 消息循环机制中的**窗口消息处理函数**。

`WndProc(ref Message m)` 方法就是一个用于处理窗口消息的回调函数。当窗口接收到不同类型的消息时（例如鼠标事件、键盘事件、绘图事件等，包括Timer的触发事件），窗口过程会被调用来处理这些消息并作出相应的响应。

大家可能会很好奇该方法中的两个判断条件是什么意思？275 和 16 分别代表什么？

实际上这个是Windows消息标识符的十进制值。实际上他们是在名为 **WinUser.h** 的c++ 头文件中定义的。它随SDK一起安装到电脑上，可以通过Everything 直接找到它。

![image.png](https://niuery.com/static/img/322e97f4d50b25319dc9ae28d5001c8d.image.png)

而我们要找的消息 275 和 16 就是下面这两个 
- WM_TIMER ：其16进制为0x0113，转化为10进制则为275。
- WM_CLOSE ：其16进制为0x0010，转化为10进制则为16。

![image.png](https://niuery.com/static/img/1e3cc6083745008dcfb09c7a8b639ff0.image.png)

这样就可以理解`WndProc(ref Message m)` 方法的作用了，就是获取到 `WM_TIMER` 消息时，触发 `System.Windows.Forms.Timer` 的 `OnTick` 方法。而获取到 `WM_CLOSE` 消息时，则调用 `StopTimer()`,结束定时器。

## 结论

通过上面的机制和源码分析，可以得出结论，`System.Windows.Forms.Timer` 并不是线程，而是依赖于UIx线程，依赖于Windows消息循环机制而实现的定时器。

所以回到开篇的问题，这个问题就有问题，`System.Windows.Forms.Timer` 并不是线程。

解读 --- System.Windows.Forms.Timer是前台线程吗?

## 引言 
最近比较忙，出差->加班->出差，已经差不多半个月没有写技术类文章了。但是，一般在没有空看技术类书籍的时候，我就会在一些碎片时间看一些软技能相关的书籍，提升软技能实力。

软技能就不用多说了，**情商，沟通，团队合作，时间管理，领导力，决策能力，创新能力，学习能力**等等，这些个人在职业和社交环境中所需的非技术性技能和个人素质，都可以称之为软技能。

我个人觉得，一个人的成长，软技能的占比是应该比“**硬技能**”更高的。在现代职场和社会中，一个人能力的体现更多的体现在软技能上，一个拥有很高的软技能实力的人能够更好地适应不断变化的工作环境，更好地与他人合作，取得更好的工作成果，并在职业生涯中更有核心竞争力。

在这里不再多述说软技能，主要是最近刚刚读完一本提升软技能的书《了不起学习者》，目标是**提升个人学习能力**，其内容能够引起我的诸多共鸣，所以想要推荐给大家。




## 《了不起的学习者》

### 介绍

《了不起学习者》这本书是一本很新的书，作者是沈文婷老师，2023年5月份首次出版，距今也不过两个月。

![535f00436eeef21883d4428abc3c973.jpg](https://niuery.com/static/img/8482646101841f3c26484194300a6c6a.535f00436eeef21883d4428abc3c973.jpg)

沈文婷老师总结自己20年求学经历和近10年投入教育与公益事业的经验后，提炼出一个核心公式：

> **了不起的学习者 = 动力 x 学习力 X 品牌力**

她认为成长就是一场“无限游戏”，成为了不起的学习者，加入一场无限游戏，她总结了诸多公式，助力成为了不起的学习者在其畅游。

![8bbe28fff07427e4a15d314c1e01a0d.jpg](https://niuery.com/static/img/1639e2a227d2b4540c99321efac3c11b.8bbe28fff07427e4a15d314c1e01a0d.jpg)

### 推荐理由

本书并无华丽辞藻，但在平实的语句中总是能够引起“学习者”的共鸣，我在阅读第一遍的时候，其实并未关注她的诸多公式，但是即使不看公式，每个单独板块也依旧有吸引力。

比如驱动力，以往我认为，在现代职场和社会中，自我学习以兴趣自驱，书中却提出了成长性思维概念用以增强驱动力，将驱动力分解为一个渐近发展的过程：好奇心->激情->使命感->自主感->掌控感。从这个渐近过程中了解到为什么不要小瞧好奇心？成熟的激情需要什么？怎么找到不凡的使命感？走向自主与获得掌控感的要点是什么？最后爆发强大的驱动力。

再比如书中提出创建学习系统公式：
> **学习力 = 认知力 + 决策力 + 行动力 + 加速器**

认知就是我们借助思考获取知识的过程，提升认知力就是我们需要知道“什么是太阳？”（事，物，概念），“什么是社会？”（感性认知），“什么是重力”（物理认知）等等，但是“为什么？”，“是什么？”的问题太多了，我们到底学什么？怎么判断信息质量，我们怎么选择使学习过程更高效，这是决策力。将知识整合形成自己的知识体系，配合高情商“与”他人学习，这是行动力。如何让自己在学习过程中更专注，更高效，并将之转化为成果，这是加速器。将之组合在一起可以创建自己的学习系统。

除此之外，仍有诸多能够引起“学习者”共鸣的内容需要大家自己去发掘，我个人认为这本书是值得读第二遍甚至第三遍的。


## 结束语
结束语就引用沈文婷老的话：
> 所谓了不起，意味着追求最佳的自己，最佳的自己不一定是好莱坞式的英雄拯救世界，而是将个人潜能充分挖掘并发挥最大价值，而学习者则是向“保持饥饿，保持愚蠢”（Stay hungry,stay foolish）的成长精神致敬。

将《了不起学习者》这本书推荐给大家，希望大家也能从中受到启发，创建属于自己的学习系统，成为“了不起学习者”。

好书推荐 --- 《了不起的学习者》

## 引言

今天看书看到了这样一个问题：

**假设有10个接口访问的日志，每个日志的大小为300M，每个文件里的日志都是按照时间戳从小到大排序的。现在我们希望将这10个较小的日志文件，合并为一个大文件，合并之后的文件依旧按照时间戳从小到大排序，如果处理上述任务的机器只有1G内存，那么该如何将这10个日志文件合并？**




一般来说，如果机器内存足够大，可以直接将所有数据全部加载到内存，然后整合到一个集合后进行排序后输出一个大文件。但并不建议这样操作，这样无节制的使用内存，可能会导致性能下降甚至程序崩溃。


## 思路

那我们如何在有限条件下处理这样的有序多文件合并为有序大文件呢？先想想C#是如何读取大文件的？

C#处理大文件的方法是使用流（Stream）而不是一次性将整个文件加载到内存中。


```csharp
int bufferSize = 1024 * 1024; // 使用1MB的缓冲区

byte[] buffer = new byte[bufferSize];

try
{
    using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
    {
        int bytesRead;

        while ((bytesRead = fileStream.Read(buffer, 0, bufferSize)) > 0)
        {
            // do something... 
        }

    }
}
catch
{

}
```

那我们要多个有序文件合并成一个文件，就反过来，我们从每个文件中取出最小的数据，然后分多路依次合并到目标文件中。这其实就是**归并排序中的 `Merge()`函数的处理思路**。想仔细了解可以看一下[数据结构与算法 --- 排序算法（二）](https://niuery.com/post/56)

## 实现
可以将文件看作数组，那问题就变成了多个有序数组合并为一个有序数组。

![image.png](https://niuery.com/static/img/d29190c239febad0403793f6a71e5449.image.png)

用C#代码实现如下：

```csharp
public static void Main()
{
    //这里暂时只使用3组数据
    int[][] sortedArrays = new int[][]
    {
        new int[] { 1, 4, 7, 10, 13 },
        new int[] { 2, 5, 8, 11, 14 },
        new int[] { 3, 6, 9, 12, 15 },

    };

    int[] mergedArray = MergeSortedArrays(sortedArrays);
    Console.WriteLine("合并后的有序数组：");
    foreach (int num in mergedArray)
    {
        Console.Write(num + " ");
    }
}

private static int[] MergeSortedArrays(int[][] arrays)
{
    int totalLength = 0;
    foreach (int[] arr in arrays)
    {
        totalLength += arr.Length;
    }

    int[] mergedArray = new int[totalLength];
    int[] currentIndex = new int[arrays.Length];

    for (int i = 0; i < totalLength; i++)
    {
        int minIndex = -1;
        int minValue = int.MaxValue;

        // 在所有数组中选择最小值
        for (int j = 0; j < arrays.Length; j++)
        {
            if (currentIndex[j] < arrays[j].Length && arrays[j][currentIndex[j]] < minValue)
            {
                minValue = arrays[j][currentIndex[j]];
                minIndex = j;
            }
        }

        // 将最小值放入合并后的数组
        mergedArray[i] = minValue;
        currentIndex[minIndex]++;
    }

    return mergedArray;
}

```
在上面的示例代码中，我们模拟创建了3个有序数组（`sortedArrays`），然后调用 `MergeSortedArrays` 方法来将这些有序数组合并为一个有序数组。在 `MergeSortedArrays` 方法中，我们使用了一个辅助数组 `currentIndex` 来记录每个有序数组当前的索引位置。然后，我们依次从所有数组中选择最小值，将其放入合并后的数组中，并更新对应数组的索引。重复这个过程直到合并后的数组填满，即得到了合并后的有序数组。

上述代码执行结果：

```csharp
合并后的有序数组：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
```

那么如果换成日志文件，为了解决内存条件限制，则可以为每个小文件及最终的排序文件，都前置一个内存缓存（数组），在读取数据时，一次性读取一批数据到内存（如同文章开头的示例），同理，写入数据时，先写数据到内存，等内存满了之后，在一次性地将内存中的数据写入到最终的排序文件中。

至于为什么要等到内存满了才写入，是因为磁盘的读写速度远慢于内存的读写速度，等到内存满了在写入，能够充分利用内存，节省执行时间，提高效率，但是还是需要注意尺度，避免程序直接崩溃

编码技巧 --- 内存有限下合并大文件

## 引言
上一篇[数据结构与算法 --- 排序算法（二）](https://niuery.com/post/56)中，介绍了分治算法思想及借助分治算法思想实现的归并排序。

本篇来讲解一下快速排序，它也是借助分治算法思想实现，但其处理思路与归并排序完全不一样。



## 快速排序

来看一下快速排序的算法原理：

### 算法图解

如果要排序数组中 $p$ 到 $r$ 的数据，那么，我们选择 $p$ 到r之间的任意一个数据作为 $pivot$（分区点），然后遍历从 $p$ 到 $r$ 的数据，将小于 $pivot$ 的放到左边，将大于或等于 $pivot$ 的放右边，将 $pivot$ 放中间，经过这一步骤处理之后，从 $p$ 到 $r$ 的数据就被分成了3部分。

假设 $pivot$ 现在的位置下标是 $q$，那么从 $p$ 到 $q-1$ 的数据都小于 $pivot$ ，中间是 $pivot$ ，从$q+1$ 到 $r$ 都是大于 $pivot$，如下图：


![image.png](https://niuery.com/static/img/984eae7eadfe44397a2f2ddb382a1f01.image.png)

根据分治的处理思想，分区完成之后，开始递归下标从 $p$ 到 $q-1$ 的数据和下标$q+1$ 到 $r$ 的数据，知道待排序区间的大小缩小为1，就说明数据都有序了。

如果使用递推公式将上面的过程表示出来，递推公式：

$$
quick\_sort(p,r)=partition(p,r)+quick\_sort(p,q-1)+quick\_sort(q+1,r) \qquad  终止条件：p \ge r
$$

其中 `partition()` 分区函数要做的就是随机选择一个元素作为 $pivot$（一般选择$p$ 到$r$区间中的最后一个元素），然后基于 $pivot$ 对区间 `Arr[p,r]` 进行分区，分区函数返回分区之后的 $piovt$ 的下标。

使用C#代码实现快速排序：

```csharp
class QuickSort
{
    public static void Sort(int[] arr)
    {
        if (arr == null || arr.Length == 0)
            return;

        QuickSortRecursive(arr, 0, arr.Length - 1);
    }

    private static void QuickSortRecursive(int[] arr, int left, int right)
    {
        if (left >= right)
            return;

        int pivotIndex = Partition(arr, left, right);
        QuickSortRecursive(arr, left, pivotIndex - 1);
        QuickSortRecursive(arr, pivotIndex + 1, right);
    }

    private static int Partition(int[] arr, int left, int right)
    {
        //这里可以选择不同的策略，比如随机数选取或选择中间值
        int pivotIndex = ChoosePivot(left, right);
        int pivotValue = arr[pivotIndex];
        Swap(arr, pivotIndex, right);

        int currentIndex = left;
        for (int i = left; i < right; i++)
        {
            if (arr[i] < pivotValue)
            {
                Swap(arr, i, currentIndex);
                currentIndex++;
            }
        }

        Swap(arr, currentIndex, right);
        return currentIndex;
    }

    private static int ChoosePivot(int left, int right)
    {
        //这里选择使用中间值
        return (left + right) / 2; 
    }

    private static void Swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
```

### 算法分析

**内存消耗**：

如果不考虑空间消耗的话，那么 `partition()` 分区函数实现非常简单，直接申请两个临时数组 X 和 Y，遍历目标区间 `Arr[p,r]` ，小于 $pivot$ 的直接复制到X，大于 $pivot$ 的直接复制到Y，最后按顺序将X，$pivot$，Y依次复制到目标区间 `Arr[p,r]`。

但是，如果这样实现的话， `partition()` 执行的过程中将消耗很多额外内存空间，快速排序也就不是原地排序算法了，如果希望快速排序是原地排序算法，该怎么做呢？

这就需要之前文章中提到的**通过交换来避免搬移**， 具体实现类似选择排序，通过游标 $i$ 把`Arr[p,r-1]` 分成两个部分，`Arr[p,i-1]` 的元素都小于 $pivot$ (也就是`Arr[r]`)，暂且称之为“已处理区间”，对应的，`Arr[i,r-1]` 是“未处理区间”。每次从未处理区间 `Arr[i,r-1]` 中取出一个元素`Arr[j]` 与 $pivot$ 对比，如果小于 $pivot$ ，则将其插入到已处理区间的尾部，也就是下标为 $i$ 的位置。具体图解可以参考[数据结构与算法 --- 排序算法（一）](https://niuery.com/post/54)中的选择排序算法图解。

**稳定性**：

理解完了快速排序是原地排序算法，那么分析一下该排序算法是否稳定排序？

其实也很简单，排序算法涉及到了分区，分区的操作实现又是按照选择排序原理实现，选择排序本身就是不稳定排序算法，所以快速排序也是不稳定排序。（）


**时间复杂度**：

1. 最好情况时间复杂度：$O(nlogn)$

   在最好的情况下，快速排序的时间复杂度为 $O(n log n)$。这种情况发生在每次划分时，待排序数组恰好被平均地分成两个大小相近的子数组。此时，快速排序的递归树的深度较小，每一层的时间复杂度为 $O(n)$，总的时间复杂度为 $O(n log n)$。

2. 最坏情况时间复杂度：$O(n^2)$
   
   在最坏的情况下，快速排序的时间复杂度为 $O(n^2)$。这种情况发生在每次划分时，待排序数组中的元素都被划分到了同一侧，导致一侧的子数组非常大，另一侧为空。这样就会导致快速排序的递归树非常不平衡，每一层的时间复杂度为 $O(n)$，而递归的层数为n，因此总的时间复杂度为 $O(n^2)$。

3. 平均情况时间复杂度：$O(n log n)$
   
   在平均情况下，快速排序的时间复杂度为 $O(n log n)$。快速排序采用分治策略，在平均情况下，待排序数组会被平均地划分成两个大小相近的子数组，这样递归树会相对平衡，每一层的时间复杂度为 $O(n log n)$，总的时间复杂度为 $O(n log n)$。

## 总结

需要注意的是，快速排序的性能高度依赖于划分元素的选择。在实际实现中，通常会采取一些优化措施，如三数取中法或随机选取划分元素，以尽量避免最坏情况的发生。总体来说，快速排序在大多数情况下表现良好，因为平均时间复杂度为$O(n log n)$，它是一种快速且高效的排序算法。
 
>参考
>
> [1] 数据结构与算法之美 / 王争 著. --北京：人民邮电出版社，2021.6

数据结构与算法 --- 排序算法（三）

## 引言

随着高性能系统越来越普遍地采用.NET环境，垃圾回收器的决策过程正在变得越来越优雅。

本篇介绍一下垃圾回收的基本运作方式。



## 小对象堆和大对象堆
在托管进程中存在两种内存堆（本机堆和托管堆）。本机内存堆(`Native Heap`)是由 `VirtualAlloc` 这个 `Windows API` 分配的，是由操作系统和CLR使用的，用于非托管代码所需的内存，比如 `Windows API` 、操作系统数据结构、很多CLR数据等。

CLR在托管堆(`Managed Heap`)上为所有.NET托管对象分配内存，也被成为GC堆，因为其中的对象均要受到垃圾回收机制的控制。

托管堆又分为两种一**小对象堆**和**大对象堆**（`LOH`),两者各自拥有自己的内存段(`Segment`)。每个内存段的大小视配置和硬件环境而定，对于大型程序可以是几百MB或更大。

小对象堆和 `LOH` 都可拥有多个内存段。小对象堆的内存段进一步划分为3代，分别是0、1、2代。第0代和第1代总是位于同一个内存段中，而第2代可能跨越多个内存段，`LOH` 也可以跨越多个内存段。包含第0代和第1代堆的内存段被称为暂时段(`Ephemeral Segment`)。

一开始内存堆就如下所示，两个内存段分别被标为 A 和 B，内存地址从左到右由小变大。小对象堆由 A 段内存构成，`LOH` 拥有 B 段内存。第 2 代和第 1 代堆只占有开头的一点内存，因为它们还都是空的。


![image.png](https://niuery.com/static/img/a55557e8db006684f1590728bfae653d.image.png)

### 小对象堆中分配内存的对象的生存期
如果对象小于 85 000 字节，CLR 都会把它分配在小对象堆中的第 0 代，通常紧挨着当前已用内存空间往后分配。因
此，正如本章开头所示，.NET 的内存分配过程非常迅速。如果快速分配失败，对象就可能会被放入第 0 代内存堆中的任意地方，只要能容纳得下就行。

如果没有合适的空闲空间，那么分配器就会扩大第 0 代内存堆，以便能存入新对象。如果扩大内存堆时超越了内存段的边界，则会触发垃圾回收过程。

对象总是诞生于第 0 代内存堆。只要对象保持存活，每当发生垃圾回收时，GC 都会把它提升一代。第 0 代和第 1 代内存堆的垃圾回收有时候被称为瞬时回收（`Ephemeral Collection`）。

在发生垃圾回收时，可能会进行碎片整理（`Compaction`），也就是 GC 把对象物理迁移到新的位置中去，以便让内存段中的空闲空间能够连续起来以备使用。如果未发生碎片整理，那就只需要重新调整各块内存的边界即可。在经历了几次未做碎片整理的垃圾回收之后，内存堆的分布可能会如下所示。


![image.png](https://niuery.com/static/img/3bd0d658896ba3ebf6de77c2de048f76.image.png)

对象的位置没有移动过，但各代内存堆的边界已经发生了变化。

每一代内存堆都有可能发生碎片整理。因为 GC 必须修正所有对象的引用，使它们指向新的位置，所以碎片整理的开销相对较大，还有可能需要暂停所有托管线程。正因如此，垃圾回收器只在划算（`Productive`）时才会进行碎片整理，判断的依据是一些内部指标。

如果对象到达了第 2 代内存堆，它就会一直留在那里直至终结。这并不意味着第 2 代内存堆只会一直变大。

如果第 2 代内存堆中的对象都终结了，整个内存段也没有存活的对象了，垃圾回收器会把整个内存段交还给操作系统，或者作为其他几代内存堆的附加段。

在进行完全垃圾回收（`Full Garbage Collection`）时，就可能发生这种第 2 代内存堆的回收。

那么“存活”是什么意思呢？如果 GC 能够通过任一已知的 GC 根对象（Root），沿着层层引用访问到某个对象，那它就是存活的。

GC 根对象可以是程序中的静态变量，或者某个线程的堆栈被正在运行的方法占用（用于局部变量），或者是 GC 句柄（比如固定对象的句柄，`Pinned Handle`），或是终结器队列（`Finalizer Queue`）。

请注意，有些对象可能没有受GC 根对象的引用，但如果是位于第 2 代内存堆中，那么第 0 代回收是不会清理这些对象的，必须等到完全垃圾回收才会被清理到。


如果第 0 代堆即将占满一个内存段，而且垃圾回收也无法通过碎片整理获取足够的空闲内存，那么 GC 会分配一个新的内存段。新的内存段会用于容纳第 1 代和第 0 代堆，老的内存段将会变为第 2 代堆。老的第 0 代堆中的所有对象都会被放入新的第 1 代堆中，老的第 1代堆同理将提升为第 2 代堆（提升很方便，不必复制数据）。现在的内存段将如下所示。


![image.png](https://niuery.com/static/img/d4813532971f1b8cfb91254a339a9f7a.image.png)


如果第 2 代堆继续变大，就可能会跨越多个内存段。LOH 堆同样也可能跨越多个内存段。无论存在多少个内存段，第 0 代和第 1 代总是位于同一个段中。以后我们想找出内存堆中有哪些对象存活时，这些知识将会派上用场。

### 大对象堆中分配内存的对象的生存期
LOH 则遵从另一套回收规则。大于 85 000 字节的对象将自动在 LOH 中分配内存，且没有什么“代”的模式。超过这个尺寸的对象通常也就是数组和字符串了。

出于性能考虑，在垃圾回收期间 LOH 不会自动进行碎片整理，但从.NET 4.5.1 开始，必要时你也可以人为发起碎片整理。

与第 2 代内存堆类似，如果 LOH 的内存不再有用了，就可能会被用于其他内存堆。不过我们以后将会看到，理想状态下你根本就不会愿意让 LOH 的内存被回收掉。在 LOH 中，垃圾回收器用一张空闲内存列表来确定对象的存放位置。


:::tip{title="提示"}
如果是在调试器中查看位于 LOH 的对象，你会发现有可能整个 LOH 都小于 85 000 字节，而且可能还有对象的大小是小于已分配值的。这些对象通常都是 CLR 分配出去的，可以不予理睬。
:::

垃圾回收是针对某一代及其以下几代内存堆进行的。如果回收了第 1 代，则也会同时回收第 0 代。

如果回收了第 2 代，则所有内存堆都会回收，包括 LOH。如果发生了第 0 代或第1 代垃圾回收，那么程序在回收期间就会暂停运行。对于第 2 代垃圾回收而言，有部分回收是在后台线程中进行的，这要根据配置参数而定。

## 垃圾回收的四个阶段
垃圾回收包含 4 个阶段。
1. 挂起（Suspension）—— 在垃圾回收发生之前，所有托管线程都被强行中止。
2. 标记（Mark）—— 从 GC 根对象开始，垃圾回收器沿着所有对象引用进行遍历并把所见对象记录下来。
3. 碎片整理（Compact）—— 将对象重新紧挨着存放并更新所有引用，以便减少内存碎片。在小对象堆中，碎片整理会按需进行，无法控制。在 LOH 中，碎片整理不会自动进行，但你可以在必要时通知垃圾回收器来上一次。
4. 恢复（Resume）——托管线程恢复运行。

在标记阶段并不需要遍历内存堆中的所有对象，只要访问那些需要回收的部分即可。

比如第 0 代回收只涉及到第 0 代内存堆中的对象，第 1 代回收将会标记第 0 代和第 1 代内存堆中的对象。

而第 2 代回收和完全回收，则需遍历内存堆中所有存活的对象，这一过程的开销有可能非常大。

这里有个小问题需要注意，高代内存堆中的对象有可能是低代内存堆对象的根对象。这样就会导致垃圾回收器遍历到一部分高代内存堆的对象，但这样的回收开销还是小于高代内存堆的完全垃圾回收。


## 结论

由上述讨论可以形成以下几点重要结论。

第一，垃圾回收过程的耗时几乎完全取决于所涉及“代”内存堆中的对象数量，而不是你分配到的对象数量。这就是说，即使你分配了 1 棵包含 100 万个对象的树，只要在下一次垃圾回收之前把根对象的引用解除掉，这 100 万个对象就不会增加垃圾回收的耗时。

第二，垃圾回收的频率取决于所涉及“代”内存堆中已被占用的内存大小。只要已分配内存超过了某个内部阈值，就会发生该“代”垃圾回收。

这个阈值是持续变化的，GC 会根据进程的执行情况进行调整。如果某“代”回收足够划算（提升了很多对象所处的“代”），那垃圾回收就会发生得频繁一些，反之亦然。

另一个触发垃圾回收的因素是所有可用内存，与你的应用程序无关。如果可用内存少于某个阈值，为了减少整个内存堆的大小，垃圾回收可能会更为频繁地发生。

由上所述，貌似垃圾回收是难以控制的，但事实不是这样。通过控制内存分配模式来控制垃圾回收的统计指标，就是一种最容易实现的优化方法。这需要理解垃圾回收的工作机制、可用的配置参数、你的内存分配率，还需要对对象的生存期有很好的控制能力。


>上述文章引用自
>
>编写高性能的.NET代码/（美）沃森(Ben Watson)著；戴旭译. --北京：人民邮电出版社，2017.8