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

04.6.2.3 并发集合与并行库

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.6 C# 与 .NET / 04.6.2 异步与并发

04.6.2.3-001 ConcurrentDictionary 有哪些核心 API?

一句话结论

提供 TryAdd/TryGetValue/TryUpdate/TryRemove/AddOrUpdate/GetOrAdd 等原子操作,键值访问内部同步,适合多线程读写映射。

概念解释

每个方法以原子语义完成单步操作,避免「先查后写」的竞态。字典内部按分片/细粒度同步降低锁竞争(具体实现以 BCL 版本为准)。

原理流程

  1. 调用 Try 系列方法。
  2. 内部定位键并原子执行。
  3. 返回是否成功与当前值。

代码或图示

var map = new ConcurrentDictionary<int, Order>();
map.TryAdd(id, order);
if (map.TryGetValue(id, out var found)) { }

常见误区

  • 把 TryGetValue 与后续修改当复合原子:两步之间其他线程可改。
  • 用并发字典替代跨字典事务:多字典一致性仍需外部同步。

追问

  • 与普通 Dictionary 性能差异?答:单操作有同步开销;无竞争场景普通字典更快,多线程共享才用并发字典。
  • 枚举线程安全?答:遍历基于弱一致快照,不阻塞写入;见迭代一致性条目。

04.6.2.3-002 GetOrAdd 工厂会执行几次?

一句话结论

GetOrAdd 不保证工厂委托只执行一次:并发下多个线程可能同时为同一键计算值,最终只保留一个结果;工厂必须无副作用或可重复执行。

概念解释

字典先尝试取值,缺失时调用工厂生成。并发竞争中工厂可能被多次调用,返回值任选其一。需要只执行一次的初始化,需额外加锁或惰性初始化模式。

原理流程

  1. 线程查键缺失。
  2. 并发线程同时执行工厂。
  3. 字典合并写入,保留一个值。

代码或图示

var cached = cache.GetOrAdd(id, k => CreateExpensive(k));
// CreateExpensive 可能被并发调用多次

常见误区

  • 工厂里做唯一副作用(发消息/扣库存):可能重复执行。
  • 以为 GetOrAdd 是双重检查锁定:语义不保证单次工厂。

追问

  • 如何保证单次初始化?答:锁内检查+创建,或 Lazy<T> 包装值;按并发要求选择。
  • AddOrUpdate 工厂同样多次执行吗?答:更新工厂在竞争下也可能被多次调用,需保持幂等。

04.6.2.3-003 ConcurrentQueue、Stack、Bag 区别?

一句话结论

ConcurrentQueue 先进先出,ConcurrentStack 后进先出,ConcurrentBag 按线程局部缓冲优化无序存取;按顺序语义与访问模式选择。

概念解释

队列适合任务排队,栈适合回溯,Bag 适合收集结果且不关心顺序。Bag 为每个线程维护局部缓冲,减少竞争,窃取机制平衡各缓冲。

原理流程

  1. 入队/压入/添加进入对应结构。
  2. 内部无锁/细粒度同步存取。
  3. 取出按各自顺序规则。

代码或图示

var q = new ConcurrentQueue<Job>();
var stack = new ConcurrentStack<Item>();
var bag = new ConcurrentBag<Result>();

常见误区

  • 用 Bag 要求 FIFO 顺序:Bag 无序,顺序需求用队列。
  • 以为三者迭代顺序严格确定:并发修改下可见性为弱一致。

追问

  • 各自 Try 方法?答:TryDequeue/TryPop/TryTake 取出失败返回 false,不抛异常。
  • 适用场景?答:任务分发用队列,结果收集用 Bag,LIFO 回溯用栈。

04.6.2.3-004 BlockingCollection 生产者消费者?

一句话结论

BlockingCollection<T> 包装并发集合提供阻塞/受限容量的生产者消费者模型:满时生产者阻塞,空时消费者阻塞,支持完成标记与批量取数。

概念解释

内部默认 ConcurrentQueue,提供 Add/TryTake 与 CompleteAdding。有界容量形成背压;消费者 GetConsumingEnumerable 阻塞等待元素。

原理流程

  1. 生产者 Add 元素,满则阻塞。
  2. 消费者枚举取出,空则等待。
  3. 生产者 CompleteAdding 后消费者排空退出。

代码或图示

using var bc = new BlockingCollection<Job>(boundedCapacity: 100);
// 生产者
bc.Add(job);
// 消费者
foreach (var job in bc.GetConsumingEnumerable()) { Process(job); }

常见误区

  • 忘记 CompleteAdding:消费者永远阻塞等待新元素。
  • 容量无界:生产者过快时内存持续增长,失去背压。

追问

  • BlockingCollection 与 Channel 对比?答:前者基于阻塞集合与传统线程模型;Channel 面向异步、无阻塞等待,支持多生产多消费与背压。
  • 取消怎么传?答:Take/Add 接受取消令牌,取消后抛 OperationCanceledException。

04.6.2.3-005 并发集合迭代的弱一致性是什么?

一句话结论

并发集合遍历期间不阻塞写入,迭代器看到的是某一时刻起的弱一致快照,不保证反映遍历开始后的所有修改;不抛集合修改异常。

概念解释

与普通集合枚举时修改抛异常不同,并发集合迭代允许并发变更。遍历结果可能包含/遗漏遍历期间新增或删除的元素,顺序按具体实现。

原理流程

  1. 获取枚举器。
  2. 遍历期间其他线程可写入。
  3. 枚举器按内部快照/弱一致规则产出元素。

代码或图示

foreach (var kv in map) { /* 不保证反映最新写入 */ }

常见误区

  • 依赖迭代结果做精确一致性判断:遍历期间状态可能已变。
  • 以为并发集合枚举会抛 InvalidOperationException:不会,弱一致可见。

追问

  • 需要一致快照怎么办?答:在外部锁内复制到普通集合再遍历,或业务层加同步。
  • 各集合可见性规则一致吗?答:大体弱一致,细节以 BCL 文档为准。

04.6.2.3-006 并发字典如何自定义键比较?

一句话结论

构造时传入 IEqualityComparer<TKey>,自定义哈希与相等规则;与普通字典相同,键相等必须哈希一致。

概念解释

比较器控制大小写、文化、复合键规则。自定义类型也可在类型上重写 Equals/GetHashCode;比较器方式不改类型定义。

原理流程

  1. 实现比较器或使用内置比较器。
  2. 字典构造传入。
  3. 插入/查找按比较器分桶与相等判断。

代码或图示

var map = new ConcurrentDictionary<string, Order>(StringComparer.OrdinalIgnoreCase);

常见误区

  • 比较器与类型默认相等规则不一致:同一键在不同结构中行为不同。
  • 可变键参与哈希:修改后哈希变化导致条目不可达。

追问

  • 复合键怎么设计?答:用 record/自定义类型作为键,实现一致相等与哈希。
  • 比较器性能?答:哈希分布影响冲突率;热点键类型应评估哈希质量。

04.6.2.3-007 Parallel.For 与 ForEach 怎么用?

一句话结论

Parallel.For/ForEach 把数据源分区到多个线程并行执行委托,自动调度与合并;适合 CPU 密集、迭代间独立的批量处理。

概念解释

并行循环由任务调度器分区执行,异常聚合到 AggregateException。迭代间不能依赖顺序或共享可变状态;需要汇总用线程局部变量。

原理流程

  1. 数据源分区。
  2. 各分区并行执行 body。
  3. 等待全部分区完成,聚合结果/异常。

代码或图示

Parallel.ForEach(items, item => Process(item));
Parallel.For(0, items.Count, i => Process(items[i]));

常见误区

  • 迭代间共享累加器不加同步:丢失更新。
  • 并行循环内做阻塞 IO:线程被等待占用,并行收益低。

追问

  • 并行与多线程关系?答:Parallel 基于任务/线程池调度,不是显式创建固定线程。
  • 迭代有副作用顺序依赖?答:并行不保证执行顺序,顺序敏感逻辑不能直接并行。

04.6.2.3-008 并行度与分区策略?

一句话结论

并行度由调度器按处理器与负载决定,可通过 MaxDegreeOfParallelism 限制;分区把数据源切成块/范围/哈希段分配给并行任务。

概念解释

分区策略影响负载均衡:范围分区适合定长索引集合,块分区平衡长短任务,哈希分区按键分散。并行度过高增加调度竞争。

原理流程

  1. 数据源按策略分区。
  2. 各分区分配并行任务。
  3. 调度器按可用 worker 执行。

代码或图示

Parallel.ForEach(items, new ParallelOptions {
    MaxDegreeOfParallelism = Environment.ProcessorCount
}, item => Process(item));

常见误区

  • 并行度设为数据源长度:线程/任务爆炸,上下文切换压垮系统。
  • 分区不均导致长尾:部分分区任务过长,整体等待最慢分区。

追问

  • 分区对 List/数组有何不同?答:定长集合可用范围分区;枚举源可能用块分区,具体实现以 BCL 为准。
  • 如何控制并行度?答:ParallelOptions.MaxDegreeOfParallelism;CPU 密集通常不超核数太多。

04.6.2.3-009 PLINQ 是什么,与 LINQ 区别?

一句话结论

AsParallel() 把 LINQ 查询转为并行执行:数据源分区、各分区并行计算、结果合并;适合 CPU 密集、迭代独立的查询。

概念解释

PLINQ 在标准查询运算符上加并行执行层。远程/IO 绑定查询不适合并行;结果合并阶段可能保留或丢弃顺序。

原理流程

  1. AsParallel() 标记数据源可并行。
  2. 查询运算符按分区并行计算。
  3. 合并结果序列返回。

代码或图示

var results = items.AsParallel()
    .Where(x => x.Valid)
    .Select(x => Compute(x))
    .ToList();

常见误区

  • 对小集合用 PLINQ:并行调度开销超过计算收益。
  • 在 PLINQ 里调用阻塞 IO:并行线程被等待占用。

追问

  • PLINQ 与 Parallel.ForEach 选择?答:声明式查询用 PLINQ;命令式循环用 Parallel;两者都面向 CPU 并行。
  • 并行查询何时退化为串行?答:调度判断收益不足或运算符不支持并行时,具体策略以 BCL 为准。

04.6.2.3-010 PLINQ 顺序保持与合并?

一句话结论

AsOrdered() 保留源顺序,代价是合并阶段需排序协调;默认无序合并更快;WithMergeOptions 控制结果缓冲与合并方式。

概念解释

并行执行打乱了元素顺序;需要输出与源对应时用 AsOrdered。合并模式控制等待多少分区结果再产出,平衡延迟与吞吐。

原理流程

  1. 分区并行计算。
  2. 合并阶段按模式汇总。
  3. AsOrdered 恢复源顺序,否则按完成顺序产出。

代码或图示

items.AsParallel().AsOrdered().Select(Compute).ToList();

常见误区

  • 无序结果却按源下标对应:顺序不保证,需带键关联。
  • 全程 AsOrdered 却无顺序需求:增加合并协调成本。

追问

  • 合并选项有哪些?答:缓冲/非缓冲等模式,枚举名与行为以 BCL 文档为准。
  • 顺序与性能权衡?答:保序限制并行合并自由度,按业务是否需要顺序选择。

04.6.2.3-011 并行循环异常如何聚合?

一句话结论

并行体中抛出的异常收集到 AggregateException,循环在其他迭代完成/终止后统一抛出;需遍历 InnerExceptions 处理各异常。

概念解释

一个迭代失败不立即中断全部;调度器记录异常,等待相关任务结束后聚合抛出。取消与异常路径需区分处理。

原理流程

  1. 各分区 body 抛异常。
  2. 异常收集进聚合容器。
  3. 循环结束抛 AggregateException,遍历内部异常。

代码或图示

try { Parallel.ForEach(items, Work); }
catch (AggregateException ae) {
    foreach (var ex in ae.InnerExceptions) { Log(ex); }
}

常见误区

  • 只 catch 原始异常类型:并行包装为聚合异常,需解包 InnerExceptions。
  • 异常后忽略其他分区:部分任务可能仍在运行,注意资源清理。

追问

  • 单异常会解包吗?答:直接 await Task 会解包;Parallel 同步 API 抛 AggregateException。
  • 异常后能否继续其余迭代?答:默认行为按调度策略;可在 body 内自行捕获记录以继续。

04.6.2.3-012 并行循环如何取消?

一句话结论

通过 ParallelOptions.CancellationToken 传入令牌,body 内观察令牌或循环在取消后停止,抛 OperationCanceledException(聚合在异常中)。

概念解释

取消是协作式:调度器收到取消信号后停止启动新迭代,已运行迭代在检查点响应。长 body 需主动检查令牌退出。

原理流程

  1. 创建令牌并放入 ParallelOptions。
  2. 循环启动并行执行。
  3. 触发取消:停止新迭代,检查点退出,抛取消异常。

代码或图示

using var cts = new CancellationTokenSource();
Parallel.ForEach(items, new ParallelOptions { CancellationToken = cts.Token },
    item => Work(item, cts.Token));

常见误区

  • body 长循环不检查令牌:已启动迭代继续跑完。
  • 把取消异常当业务错误:应与数据处理异常分别 catch。

追问

  • 取消后已分配资源?答:在 body/finally 中清理;部分完成的结果按业务决定是否丢弃。
  • PLINQ 取消?答:同样通过 WithCancellation 传入令牌。

04.6.2.3-013 并行循环的线程局部变量?

一句话结论

Parallel.For/ForEach 支持线程局部泛型状态:每个分区初始化局部值,body 内更新,最后汇总到线程局部合并委托,避免共享累加器竞争。

概念解释

局部变量按分区独立维护,减少同步;合并阶段把各分区结果汇总。典型用途:分组收集、局部计数、聚合统计。

原理流程

  1. localInit 创建分区局部状态。
  2. body 更新局部值。
  3. localFinally 把局部结果合并到共享汇总。

代码或图示

Parallel.ForEach(items,
    () => new List<Result>(),
    (item, state, local) => { local.Add(Process(item)); return local; },
    local => lock(_sum) _sum.AddRange(local));

常见误区

  • 仍用共享集合 Add:退化为串行竞争,失去局部缓冲意义。
  • 合并委托未加同步:汇总阶段多分区并发写共享结果。

追问

  • 局部变量生命周期?答:随分区任务存活,分区结束后执行合并委托。
  • 替代方案?答:Bag 收集各分区结果,最后统一汇总。

04.6.2.3-014 并行与异步的区别?

一句话结论

并行利用多核同时计算多个 CPU 任务;异步处理等待(IO/延迟)时不占线程;并行是吞吐加速,异步是等待不阻塞,二者可组合但目标不同。

概念解释

CPU 密集批量处理用 Parallel/PLINQ;IO 并发用 async/await。并行循环内不应阻塞等待 IO;异步批量并发用 WhenAll + 限流。

原理流程

  1. 判断工作类型:计算并行,IO 异步。
  2. CPU:分区多线程同时算。
  3. IO:提交异步请求,等待期释放线程。

代码或图示

Parallel.ForEach(computeItems, CpuWork);          // 并行计算
await Task.WhenAll(ioItems.Select(IoWork));        // 异步 IO

常见误区

  • 用 Parallel 跑网络请求:线程被阻塞等待,并发能力差。
  • 用 async 批量做重计算:等待期仍占线程,应配合 Task.Run/并行。

追问

  • 混合场景怎么拆?答:IO 异步提交,返回结果后 CPU 计算再并行;分段处理。
  • 并行库有异步版本吗?答:Parallel 是同步阻塞 API;异步批量用 Task 组合与信号量限流。

04.6.2.3-015 并发字典更新方法与原子语义?

一句话结论

AddOrUpdate 组合添加/更新委托,TryUpdate 按期望值条件替换;各方法内部原子执行,但更新工厂在竞争下可能多次调用。

概念解释

更新方法先查当前值,调用对应委托生成新值,原子写入。条件更新可比较旧值,避免覆盖他人修改。

原理流程

  1. 读取当前键值。
  2. 调用添加/更新委托。
  3. 原子写入新值,竞争失败可重试(内部实现)。

代码或图示

map.AddOrUpdate(id,
    k => new Order(k),
    (k, old) => old with { Version = old.Version + 1 });

常见误区

  • 更新委托依赖外部唯一副作用:竞争下可能多次执行。
  • 期望条件更新串行化跨字典:单字典原子不覆盖多字典一致性。

追问

  • TryUpdate 期望值参数?答:比较当前值与预期值,匹配才替换,返回是否成功。
  • 数值原子累加怎么做?答:循环 CAS/CompareExchange 模式,或用锁保护计数。

04.6.2.3-016 并发集合适用与不适用场景?

一句话结论

适用:多线程共享单步读写、生产者收集结果、任务队列;不适用:复合一致性、跨多集合事务、强顺序保证、低竞争单线程场景。

概念解释

并发集合解决单操作线程安全,不替代业务层事务与锁。无竞争时普通集合更快;需要多状态原子联动时外部同步。

原理流程

  1. 识别访问模式与一致性边界。
  2. 单步共享选并发集合。
  3. 复合/事务选锁或专门设计。

代码或图示

单步 Add/Take  → 并发集合
检查-修改-通知 → 锁保护
多字典联动     → 外部事务/同步

常见误区

  • 以为上了并发集合就高枕无忧:复合竞态仍在。
  • 单线程程序引入并发集合:多余同步开销。

追问

  • 读多写少选什么?答:不可变快照或读写锁;并发字典按实现有分片同步。
  • 大对象队列选什么?答:队列/Bag 传引用,不复制对象;注意对象生命周期。

04.6.2.3-017 并行分区策略有哪些?

一句话结论

常见分区:范围分区(定长索引按区间切分)、块分区(小块交替分配平衡负载)、哈希分区(按键哈希分散);策略影响负载均衡与协调成本。

概念解释

范围分区切分简单但长短任务不均;块分区动态分配小块,长尾更均衡;哈希分区用于按键归组场景。具体默认策略由 PLINQ/Parallel 数据源类型决定。

原理流程

  1. 数据源类型决定可用分区器。
  2. 元素按策略分配到分区。
  3. 分区并行执行,结果合并。

代码或图示

数组/List → 范围分区
枚举源   → 块分区
按键归组 → 哈希分区

常见误区

  • 任务耗时差异大用范围分区:快分区先完成,慢分区拖尾。
  • 哈希分区后期待顺序:按键分散破坏源顺序。

追问

  • 自定义分区器?答:可实现 Partitioner 基类控制切分;高级场景使用,默认分区多数够用。
  • 分区数与并行度关系?答:分区服务于并行度,调度器在分区上分配 worker。

04.6.2.3-018 如何判断并行是否有收益?

一句话结论

先基准测量单线程耗时与并行后耗时,考虑数据规模、计算密度、调度开销与共享竞争;小数据/轻计算/IO 绑定并行通常负收益。

概念解释

并行收益 = 计算节省 − 调度/分区/合并/同步成本。热点重计算、大数据量才值得并行;迭代间必须独立,避免共享锁抵消收益。

原理流程

  1. 基准测量单线程总耗时。
  2. 并行后测 wall time 与吞吐。
  3. 对比 CPU 利用率与分配/竞争成本,决定保留还是回退。

代码或图示

// BenchmarkDotNet 对比串行 vs 并行,统计耗时/分配

常见误区

  • 凭直觉开并行:小任务调度开销大于收益。
  • 并行后只看总耗时不看 CPU:可能多核忙等而吞吐未提升。

追问

  • 并行加速比上限?答:受串行段(Amdahl 定律)与调度/内存带宽限制。
  • 什么时候回退串行?答:数据量小、计算轻、共享竞争重或 IO 等待为主。