罗罗编程学习记录
本页内容 展开查看

09.4 阶段 3:CLR、运行时与并发基础

所属:全栈开发面试题库 / 学习路径 / 09 C# 与 .NET 全栈

本页目录

一、阶段定位

前三个阶段解决"写得出、写得现代",本阶段解决"为什么会变慢、为什么会偶发错"。重点是两条主线:

  1. 托管内存与 GC:对象在托管堆上怎么分配、什么时候被回收、分代(0/1/2)与大对象堆(LOH)怎么运转、GCSettings.LatencyMode 怎么影响回收时机。这决定了"内存为什么涨不下来""为什么偶发卡顿"。
  2. 线程池与并发:Task 怎么被线程池调度、CancellationToken 怎么取消、共享可变状态不加同步会出什么竞态。这决定了"为什么并发上去后吞吐上不去""为什么偶尔数据错了"。

本阶段与前后阶段的衔接:往上承接阶段 2 的 async/await——本阶段讲清它背后靠线程池与状态机运转;往下接 阶段 4 工具链、工程化与测试,那时讨论的测试与性能指标都建立在"能看懂 GC 次数、线程池队列"的基础上。跳过 GC 与并发直接进 Web 框架,后面遇到"偶发内存泄漏""接口偶发慢"时只能靠猜。

原有卡点的可判断现象依据:

  • 手写 GC.Collect() 试图解决内存泄漏:判断标准是——发现内存高就手动调 GC.Collect(),却不知道这只是强制回收一次、不解决根因,还会打断 GC 的分代调度。
  • 把终结器当确定性释放:判断标准是——以为写了 ~Class()(终结器)就一定在某时刻释放资源,却不知道它是非确定性的、由 GC 在未来某个时间触发。
  • 线程池饥饿:判断标准是——大量同步阻塞任务占满线程池,后续 Task 排队等待,接口吞吐上不去却看不出原因。
  • 共享可变状态不加同步:判断标准是——多线程改同一个计数器,结果时大时小,偶发错但单测复现不了。

二、阶段目标与投入

学完本页,应当能用可观察的行为证明以下六条能力:

能力目标(可验证的行为) 验证方式
能画出一次 GC 从标记到压缩的流程 口述"分代—标记—可达性—压缩"
能解释 LOH 为什么通常不压缩 说出大对象堆的代价与碎片问题
能写一个带 CancellationToken 的并发处理程序 取消时任务能及时退出
能用并发集合替代手写锁集合 ConcurrentDictionary 无锁安全并发读写
能识别线程池饥饿现象 说出"队列堆积、吞吐上不去"的判断
能说明 Dispose 与终结器的分工 写出标准 Dispose 模式

建议学时:

  • 全职(每天有效学习 4–6 小时):2 周,约 60 小时。
  • 在职(每天 2 小时、周末补 4 小时):5 周。

学时分配建议:托管堆与对象分配 15%、GC 分代与 LOH 25%、终结器与 Dispose 模式 15%、线程池与 Task 调度 15%、CancellationToken 10%、锁与并发集合 20%。GC 与并发是线上问题的重灾区。

三、先修自检

进入本阶段前逐条自检;任何一条做不到,先回到对应页面补齐。

先修项 合格标准 不合格时回到
值/引用类型 能说清对象在堆与栈的分配 09.2 阶段 1
async/await 能写异步方法,说清状态机 09.3 阶段 2
IDisposable 能写 using 释放资源 09.2 阶段 1
集合与 LINQ 能说清延迟执行 09.2 阶段 1

四、知识地图

"掌握程度"分三档:了解、会用、能讲清原理。

模块 知识点 掌握程度 对应题库章节
托管堆与栈 对象分配、可达性判定、根引用 能讲清原理 04.6 CSharp 与 .NET
GC 分代与 LOH 0/1/2 代晋升、大对象阈值、压缩策略、GCSettings.LatencyMode 能讲清原理 04.6 CSharp 与 .NET
终结器与 Dispose 终结队列、非确定性、标准 Dispose 模式 能讲清原理 04.6 CSharp 与 .NET
线程池与 Task 任务调度、队列、线程池饥饿 会用 04.6 CSharp 与 .NET
取消模型 CancellationToken、CancellationTokenSource 会用 04.6 CSharp 与 .NET
锁与并发集合 lock/Monitor、竞态条件、ConcurrentDictionary 能讲清原理 04.6 CSharp 与 .NET

进度管理建议:把这张表复制到笔记里,三档都到位再进 阶段 4。《知识点全清单》是更细的全量清单。

五、分模块精讲

5.1 托管堆与对象分配

为什么需要它:不理解对象在哪分配、谁决定它能不能活,就无法解释"为什么内存一直涨""为什么这个对象回收不掉"。

核心机制:

  • 栈:存值类型、方法参数、返回地址,方法返回即回收,自动管理。
  • 托管堆:存引用类型对象。对象分配在"新对象空间"(三代堆的 0 代区)。
  • 可达性判定:GC 从"根"(静态字段、局部变量、CPU 寄存器)出发,标记所有可达对象;不可达对象即垃圾,被回收。
  • 压缩:回收后把存活对象 compact 到一起,消除碎片,让下一次分配从一个连续指针位置开始(分配很快)。
  • 大对象(≥85,000 字节)进入 LOH,不随普通 0/1/2 代一起压缩。

最小可运行示例:

// 观察对象在堆上的分配与 GC
var big = new byte[100_000]; // 超过 85,000 字节,进入 LOH
Console.WriteLine(GC.GetGCMemoryInfo().HeapSizeBytes); // 看堆大小

WeakReference weak = new WeakReference(big);
big = null;            // 去掉强引用
GC.Collect();          // 强制回收(仅演示,生产不要这么写)
Console.WriteLine(weak.IsAlive); // 可能为 False:对象已被回收

常见坑:

现象 原因 修法
内存持续涨不下来 静态集合或长生命周期事件持有对象 找根引用链,断开长生命周期持有
GC.Collect() 后内存仍高 还有可达根引用 用诊断工具找是谁在引用
大数组导致 LOH 碎片 频繁分配大对象 复用缓冲,或减少大对象分配

面试考法:常见问法是"对象什么时候会被回收""什么是可达性"。要答出:不可达对象(从根出发走不到)才会被回收;静态字段、活着的局部变量都是根。

5.2 GC 分代与 LOH

为什么需要它:GC 不是一次性全扫,而是分代——大部分对象"朝生夕死",老对象活得久。分代让回收成本可控,也解释了偶发卡顿。

核心机制:

  • 0 代:最新分配的对象,回收最频繁。
  • 1 代:挺过一次 0 代回收的对象,是"中年"。
  • 2 代:挺过多次回收的长生命周期对象,回收成本最高。
  • 晋升:对象挺过一次回收就晋升一代;2 代回收(full GC)会暂停整个进程。
  • LOH(大对象堆):≥85,000 字节的对象,默认不压缩(移动大对象代价高),会产生碎片。
  • GCSettings.LatencyMode:控制 GC 的停顿策略。Interactive(默认,平衡吞吐与延迟)、LowLatency(短时间减少回收,适合UI动画)、SustainedLowLatency(较长时间低延迟)、Batch(吞吐优先,暂停更长)。

最小可运行示例:

// 观察分代
var obj = new byte[100]; // 小对象,初始在 0 代
Console.WriteLine(GC.GetGeneration(obj)); // 0
GC.Collect();
Console.WriteLine(GC.GetGeneration(obj)); // 1:挺过一次晋升

// 临时切换为低延迟模式(适合 UI 动画/直播推流)
var oldMode = GCSettings.LatencyMode;
GCSettings.LatencyMode = GCLatencyMode.LowLatency;
try
{
    // 做一段对延迟敏感的工作
}
finally
{
    GCSettings.LatencyMode = oldMode; // 务必恢复
}

常见坑:

现象 原因 修法
偶发长时间卡顿 2 代 full GC 暂停进程 减少长生命周期大对象,降低 LOH 压力
LOH 内存碎片、明明有空闲却 OOM 大对象堆不压缩 复用缓冲,减少大对象分配
LowLatency 用太久导致内存涨 抑制回收太久 用完立即恢复为 Interactive
频繁 2 代回收导致 CPU 高 0 代对象频繁晋升 减少对象分配、复用对象池

面试考法:高频题是"GC 分代为什么这样设计""LOH 为什么不压缩""GCSettings.LatencyMode 有哪些值"。要答出:大部分对象朝生夕死,分代让回收成本与对象寿命匹配;LOH 移动大对象代价高故默认不压缩;LatencyMode 在吞吐与停顿间权衡。

5.3 终结器队列与 Dispose 模式

为什么需要它:持有非托管资源(文件句柄、连接、原生内存)的对象,光靠 GC 不可靠——GC 回收时机不确定。需要标准 Dispose 模式,让调用方确定性释放。

核心机制:

  • 终结器(~ClassName()):由 GC 在回收前调用,非确定性,你不知道它何时跑。
  • Dispose 模式:IDisposable.Dispose() 让调用方确定性释放;终结器作为"兜底"——忘了 Dispose 时由 GC 最终调一次。
  • 规则:Dispose 已释放资源后,要 GC.SuppressFinalize(this) 告诉 GC 不用再跑终结器。
  • 终结器不能替代 Dispose:它慢、时机不可控、还会让对象多活一代(进终结队列)。

最小可运行示例:

public class FileHandle : IDisposable
{
    private bool _disposed = false;

    // 兜底:万一调用方忘了 Dispose
    ~FileHandle() => Dispose(false);

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // 已释放,不再需要终结器
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
        if (disposing)
        {
            // 释放托管资源
        }
        // 释放非托管资源(文件句柄等)
        _disposed = true;
    }
}

常见坑:

现象 原因 修法
资源释放时机不可控 只靠终结器 调用方用 using 确定性 Dispose
对象多活了一代 写了终结器但从不调用 Dispose 用完即 Dispose,SuppressFinalize
Dispose(true) 后还访问资源 释放后继续用 释放后丢弃引用,或在方法里判 _disposed

面试考法:高频题是"终结器和 Dispose 的关系""为什么需要 SuppressFinalize"。要答出:Dispose 是确定性释放,终结器是忘了 Dispose 的兜底;SuppressFinalize 避免对象多活一代、少进终结队列。

5.4 线程池与 Task 调度

为什么需要它:async/await 的回调、Task.Run 的工作都由线程池调度。不理解线程池如何扩容、为什么会饥饿,就解释不了"并发上去后吞吐反而下降"。

核心机制:

  • 线程池维护一组可复用线程,任务排队执行;新任务来了优先复用空闲线程,不够时慢慢扩容。
  • Task.Run 把工作项丢给线程池;async/await 的续延也由线程池调度。
  • 线程池饥饿:大量任务同步阻塞(.Result、.Wait())占住线程,新任务排队,扩容又慢,吞吐上不去。
  • 线程池有最小线程数,扩容是渐进的(避免瞬间创建大量线程),所以排队时不会立刻变快。

最小可运行示例:

// 错误示范:同步阻塞占满线程池
var tasks = Enumerable.Range(0, 100)
    .Select(_ => Task.Run(() => {
        // 同步阻塞 1 秒,占住线程
        Thread.Sleep(1000);
    }))
    .ToArray();
Task.WaitAll(tasks);

// 正确做法:异步等待,不占线程
var asyncTasks = Enumerable.Range(0, 100)
    .Select(async _ => await Task.Delay(1000))
    .ToArray();
await Task.WhenAll(asyncTasks);

常见坑:

现象 原因 修法
并发上去后吞吐反而降 同步阻塞占满线程池 全程异步,不要 .Result/.Wait()
任务排队很久才开始 线程池扩容慢 减少同步阻塞,或预热
后台任务延迟高 线程池被其他任务占满 隔离关键任务,或用专用线程

面试考法:常见问法是"线程池为什么会饥饿""为什么 async 能提高吞吐"。要答出:同步阻塞占住线程、新任务排队;异步 IO 等待时不占线程,一个线程可服务多个请求,吞吐更高。

5.5 CancellationToken 取消

为什么需要它:用户取消请求、服务关停、超时,都需要任务能及时退出。没有取消模型,任务会一直跑到结束,浪费资源。

核心机制:

  • CancellationTokenSource 发取消信号;Token 传给任务。
  • 任务内部定期检查 token.IsCancellationRequested,或 token.ThrowIfCancellationRequested() 抛 OperationCanceledException。
  • 异步 API(HttpClient.GetAsync、DbContext)大多接受 CancellationToken,取消时提前退出。
  • 取消是协作式的:你请求取消,任务要自己检查并退出,框架不会强制杀线程。

最小可运行示例:

using var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(1)); // 1 秒后自动取消

try
{
    await DoWorkAsync(cts.Token);
}
catch (OperationCanceledException)
{
    Console.WriteLine("任务已被取消");
}

async Task DoWorkAsync(CancellationToken ct)
{
    for (int i = 0; i < 100; i++)
    {
        ct.ThrowIfCancellationRequested(); // 协作式检查
        await Task.Delay(100, ct);
    }
}

常见坑:

现象 原因 修法
取消后任务还在跑 任务没检查 token 在循环/关键路径加 ThrowIfCancellationRequested
取消抛了异常却没捕获 没 catch OperationCanceledException 捕获它或让上层处理
超时不生效 没把 token 传给底层 API 把 token 一路传到 HttpClient/数据库调用

面试考法:常见问法是"取消是强制的吗"。要答出:不是,是协作式——任务要自己检查 token 并退出;底层 API 接受 token 会提前结束 IO。

5.6 锁、竞态条件与并发集合

为什么需要它:多线程改同一份数据,不加同步就会偶发错(计数少了、金额错了),但单测又复现不了。这是并发最常见的线上问题。

核心机制:

  • 竞态条件:多个线程读写共享可变状态,结果取决于执行顺序,时对时错。
  • lock(obj):用 Monitor 保证同一时刻只有一个线程进入临界区,obj 是锁对象。
  • 并发集合:ConcurrentDictionary、ConcurrentQueue 内部做了细粒度同步,不用手写 lock,性能更好。
  • 锁要选对对象:不要锁 this、typeof()、字符串(可能被共享),用私有 readonly 锁对象。

最小可运行示例:

int counter = 0;
object _lock = new();
var tasks = Enumerable.Range(0, 100)
    .Select(_ => Task.Run(() =>
    {
        for (int i = 0; i < 1000; i++)
        {
            lock (_lock) { counter++; } // 加锁:原子自增
        }
    }))
    .ToArray();
await Task.WhenAll(tasks);
Console.WriteLine(counter); // 100000:不加锁会少

// 用并发集合替代手写锁
var dict = new ConcurrentDictionary<string, int>();
Parallel.For(0, 100, i => dict.AddOrUpdate("k", 1, (_, v) => v + 1));

常见坑:

现象 原因 修法
计数结果时大时小 多线程无锁改共享变量 用 lock 或 Interlocked/并发集合
死锁 两个线程各持一个锁等对方释放 统一加锁顺序,避免嵌套锁
锁 this 导致外部代码也被锁 锁对象公开 用私有 readonly 锁对象
单测复现不了 竞态取决于时序 用并发循环压测,或审查共享状态

面试考法:高频题是"什么是竞态条件""lock 锁对象怎么选"。要答出:多线程读写共享可变状态结果不确定;用私有 readonly 锁对象,不要锁 this/typeof/字符串;能并发集合就别手写锁。

六、分层练习

三档练习逐档升级,上一档没做完不要跳。

6.1 复现型(照着做,目标是跑通 + 能解释)

练习 要求 验收标准 预计耗时
观察分代晋升 用 GC.GetGeneration 看对象从 0 代到 1 代 能口述晋升过程 1 小时
写标准 Dispose 模式 实现 IDisposable + 终结器 能说清 SuppressFinalize 的作用 1.5 小时
取消示例 用 CancellationTokenSource 取消任务 1 秒后任务退出并抛 OperationCanceledException 1 小时
复现竞态条件 100 线程无锁自增计数器 结果小于 100000 1 小时
用并发集合修复 改用 ConcurrentDictionary 结果正确 1 小时

6.2 改造型(给出现成代码,改出正确行为)

练习 要求 验收标准 预计耗时
修复线程池饥饿 给定大量 .Result,改成异步 吞吐提升,无阻塞 1.5 小时
把手写锁集合改成并发集合 用 ConcurrentDictionary 替代 lock 结果正确,代码更简 1.5 小时
加取消令牌 给一个循环任务加 token 检查 取消时及时退出 1 小时
修 LOH 碎片 给定频繁大数组分配,改成复用缓冲 LOH 分配下降 2 小时

6.3 设计型(自己定方案,目标是能交付、能讲清取舍)

练习 要求 验收标准 预计耗时
并发处理流水线 用 CancellationToken + 并发集合做数据处理管道 可取消、结果正确、无竞态 5 小时
对象池复用设计 为高频缓冲设计对象池,减少 LOH 压力 GC 次数下降 4 小时
内存泄漏排查报告 用诊断工具找长生命周期持有 给出根因与修复 4 小时

七、排障表

现象 可能原因 排查步骤 解决办法
内存持续涨不下来 静态集合/事件持有对象 用诊断工具看根引用链 断开长生命周期持有,正确退订
偶发长时间卡顿 2 代 full GC 暂停进程 看 GC 次数与代际 减少大对象与长生命周期对象
LOH 有空闲却 OOM 大对象堆碎片 看 LOH 大小与碎片 复用缓冲,减少大数组分配
并发上去吞吐反而降 线程池被同步阻塞占满 看线程池队列长度 全程异步,去掉 .Result/.Wait()
计数结果时大时小 多线程无锁改共享状态 加锁前后对比 用 lock/Interlocked/并发集合
取消后任务还在跑 没检查 token 看任务内是否检查 加 ThrowIfCancellationRequested
资源释放时机不可控 只靠终结器 看调用方是否 Dispose 用 using 确定性释放
死锁 两个线程互相等锁 看锁获取顺序 统一加锁顺序,避免嵌套

八、出口条件

全部勾选后再进入 阶段 4 工具链、工程化与测试。

  • [ ] 能画出一次 GC 从标记到压缩的流程,说清分代晋升
  • [ ] 能解释 LOH 为什么通常不压缩、GCSettings.LatencyMode 的取值与用途
  • [ ] 能写标准 Dispose 模式,说清终结器与 SuppressFinalize 的分工
  • [ ] 能识别线程池饥饿,并用全程异步修复
  • [ ] 能写带 CancellationToken 的并发处理程序
  • [ ] 能用并发集合替代手写锁集合,说清竞态条件
  • [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径

自测题(先自己想,再看要点):

  1. 对象什么时候会被回收?
    • 要点:不可达对象——从根(静态字段、活的局部变量、寄存器)出发走不到的对象。
  2. LOH 为什么通常不压缩?
    • 要点:移动大对象代价高(要拷贝大量内存),故默认不压缩,代价是碎片。
  3. GCSettings.LatencyMode.LowLatency 用在什么场景?
    • 要点:短时间对延迟敏感的工作(如 UI 动画),减少 GC 停顿;用完要恢复。
  4. 为什么终结器不能替代 Dispose?
    • 要点:它非确定性、时机不可控,还让对象多活一代进终结队列;Dispose 才是确定性释放。
  5. 线程池饥饿是什么现象?
    • 要点:同步阻塞占住线程,新任务排队,扩容慢,并发上去吞吐反而降。
  6. CancellationToken 是强制取消吗?
    • 要点:不是,协作式——任务要自己检查 token 并退出;底层 API 接受 token 才提前结束 IO。
  7. 多线程自增计数器为什么结果会少?
    • 要点:i++ 不是原子操作(读-改-写),多线程交错导致丢失更新;用 lock/Interlocked/并发集合。