09.4 阶段 3:CLR、运行时与并发基础
所属:全栈开发面试题库 / 学习路径 / 09 C# 与 .NET 全栈
本页目录
一、阶段定位
前三个阶段解决"写得出、写得现代",本阶段解决"为什么会变慢、为什么会偶发错"。重点是两条主线:
- 托管内存与 GC:对象在托管堆上怎么分配、什么时候被回收、分代(0/1/2)与大对象堆(LOH)怎么运转、
GCSettings.LatencyMode怎么影响回收时机。这决定了"内存为什么涨不下来""为什么偶发卡顿"。 - 线程池与并发:
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 分钟内给出排查路径
自测题(先自己想,再看要点):
- 对象什么时候会被回收?
- 要点:不可达对象——从根(静态字段、活的局部变量、寄存器)出发走不到的对象。
- LOH 为什么通常不压缩?
- 要点:移动大对象代价高(要拷贝大量内存),故默认不压缩,代价是碎片。
GCSettings.LatencyMode.LowLatency用在什么场景?- 要点:短时间对延迟敏感的工作(如 UI 动画),减少 GC 停顿;用完要恢复。
- 为什么终结器不能替代 Dispose?
- 要点:它非确定性、时机不可控,还让对象多活一代进终结队列;Dispose 才是确定性释放。
- 线程池饥饿是什么现象?
- 要点:同步阻塞占住线程,新任务排队,扩容慢,并发上去吞吐反而降。
CancellationToken是强制取消吗?- 要点:不是,协作式——任务要自己检查 token 并退出;底层 API 接受 token 才提前结束 IO。
- 多线程自增计数器为什么结果会少?
- 要点:
i++不是原子操作(读-改-写),多线程交错导致丢失更新;用lock/Interlocked/并发集合。
- 要点: