一个统计任务开了八个线程,每个线程把共享计数器加一万次,跑完打印结果,有时是 80000,有时是 79000 多。代码看起来就是一句 counter++,怎么会少?因为 counter++ 不是一步完成的,它要读当前值、加一、再写回去。两个线程同时读到同一个旧值,各自加一写回,其中一个的结果就被覆盖了。
这类问题叫竞态条件。它不一定每次都发生,和线程调度、CPU 核数、运行时的优化都有关系,所以本地测试经常是「对的」,压测或线上才暴露。多线程编程难的地方不在写线程,而在保证共享状态在并发访问下仍然正确。
这篇讲 C# 多线程的几个基础构件:Thread 和 Task.Run 的区别、lock 到底锁了什么、Interlocked 和 ConcurrentDictionary 怎么用、死锁是怎么形成的、线程池饥饿为什么会让异步代码变慢。示例在本机 .NET 8 控制台项目里跑过,输出照实贴出。线程在操作系统层面怎么调度,可以回看 线程调度那一篇。
先复现那个「少了一点」的计数器
下面这段代码用 8 个任务,每个任务把共享计数器加一万次。先直接加,再用 lock 保护,最后用 Interlocked 做原子加,三种写法放在一起对比:
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static int counter = 0;
static readonly object gate = new object();
static void Main()
{
var tasks = new List<Task>();
for (int i = 0; i < 8; i++)
tasks.Add(Task.Run(() => { for (int j = 0; j < 10_000; j++) lock (gate) counter++; }));
Task.WaitAll(tasks.ToArray());
Console.WriteLine($"lock counter={counter}");
int atomic = 0;
tasks.Clear();
for (int i = 0; i < 8; i++)
tasks.Add(Task.Run(() => { for (int j = 0; j < 10_000; j++) Interlocked.Increment(ref atomic); }));
Task.WaitAll(tasks.ToArray());
Console.WriteLine($"interlocked={atomic}");
var map = new ConcurrentDictionary<int, int>();
Parallel.For(0, 1000, i => map.AddOrUpdate(i % 10, 1, (k, v) => v + 1));
Console.WriteLine($"dict[0]={map[0]} total={map.Values.Sum()}");
var a = new object();
var b = new object();
var t1 = Task.Run(() => { lock (a) { Thread.Sleep(100); lock (b) { } } });
var t2 = Task.Run(() => {
if (Monitor.TryEnter(b))
{
try
{
Thread.Sleep(10);
if (!Monitor.TryEnter(a, 300)) Console.WriteLine("deadlock risk detected");
}
finally { Monitor.Exit(b); }
}
});
Task.WaitAll(t1, t2);
Console.WriteLine("done");
}
}
本机 dotnet run 输出:
lock counter=80000
interlocked=80000
dict[0]=100 total=1000
deadlock risk detected
done
lock 和 Interlocked 都得到了正确的 80000。ConcurrentDictionary 的一千次更新分布在 10 个键上,每个键正好 100 次,总数 1000。死锁检测那一段这次打印了风险提示,说明两个任务确实差点互相等死,最后靠超时放弃了其中一把锁,程序才继续走完。具体是否打印取决于线程调度,多跑几次可能不同,但只要程序能结束,就说明超时机制生效了。
如果去掉 lock,直接让 8 个任务执行 counter++,结果通常会小于 80000,但具体少多少每次都不一样。这不是「偶尔算错」,而是「没加保护就一定会错,只是错多少看运气」。
为什么本地跑几次可能又是对的?因为任务太少、循环太短时,线程可能刚好错开执行,竞态窗口没有被撞上。CPU 核数、操作系统调度、JIT 优化都会影响结果。把循环次数加大、任务数加多、同时跑几遍,问题就更容易出现。判断并发代码是否正确,不能靠「跑一次没出错」。
Thread 和 Task.Run 不是一回事
Thread 是对操作系统线程的直接封装。new 一个 Thread 就真的创建一个线程,启动、等待、结束都由你控制。它适合需要长时间运行、需要设置线程优先级或前台后台属性的场景,但创建成本高,数量多了会拖垮系统。
Task.Run 把工作提交给线程池,由线程池决定用哪个线程、什么时候执行。它返回一个 Task,可以被等待、组合、取消。绝大多数业务代码应该用 Task,不要手动 new Thread。线程池会复用线程,避免频繁创建销毁,也能控制并发数量。
Thread
直接对应一个系统线程。创建和销毁成本高,数量受系统限制。适合长期驻留的后台循环、需要精确控制线程属性的场景。没有返回值,异常处理也更原始。
Task.Run
提交到线程池,复用线程。支持返回值、等待、组合、取消和异常传播。适合短小的后台计算。注意它只负责「在线程池上跑」,不自动解决共享状态问题。
还有一个常见误解:Task.Run 不等于「多线程一定更快」。如果任务本身很短,提交和调度的开销可能超过计算本身;如果任务是 I/O 等待,占着线程池线程反而浪费。I/O 密集的操作应该用异步 API,而不是用 Task.Run 包一层同步阻塞调用。
判断该不该并行,先问三个问题:任务之间是否独立、是否有共享状态、并行带来的收益是否超过调度成本。三个问题有一个不满足,就应该重新设计,而不是硬加线程。
还有一个容易混淆的点:Task.Run 和 async/await 不是替代关系。Task.Run 是「把这段同步代码放到线程池上跑」,async/await 是「等待异步操作完成,期间不占线程」。CPU 密集的计算可以放进 Task.Run,I/O 等待应该直接用异步 API。把同步 I/O 放进 Task.Run 只是把阻塞换了个地方,线程池的线程照样被占着。
lock 锁的到底是什么
lock 是 Monitor.Enter 和 Monitor.Exit 的语法糖。它需要一个引用类型的对象作为锁,进入代码块时尝试获取这个对象的监视器,离开时释放。同一时刻只有一个线程能持有同一个对象的锁,其他线程会阻塞等待。
锁对象的选择有几条实用规则。第一,锁对象应该是私有的,不要用 this、类型对象或字符串字面量。外部代码也可能锁 this,两个不相关的代码路径用同一把锁,容易互相阻塞。字符串还有驻留问题,内容相同的字面量可能是同一个对象,更容易产生意外共享。
第二,不要锁值类型。lock (5) 连编译都过不了,因为装箱后的对象每次都不一样,锁的根本不是同一个东西。第三,锁的粒度要合理。锁太大,所有线程排队,并发退化成串行;锁太小,可能保护不住需要一起修改的多个字段,出现只改了一半的中间状态。
锁保护的是「一段代码对共享状态的访问」,不是「某个变量」。如果两个方法分别修改同一组字段,它们必须用同一把锁。只用不同的锁保护不同字段,看似并行,实际上可能读到不一致的组合状态。设计时先想清楚哪些字段必须一起变化,再决定锁的边界。
锁的另一个代价是它会让线程排队,但不保证公平。等待最久的线程不一定先拿到锁,具体顺序由运行时和操作系统决定。不要依赖锁的获取顺序来实现业务逻辑,比如「先到的请求先处理」。需要严格顺序时,用队列或信号量,而不是靠锁。
Interlocked 和并发集合:能不锁就不锁
对于简单的计数、累加、交换,Interlocked 提供原子操作,不需要锁,性能更好。Interlocked.Increment 把加一做成一个不可分割的操作,其他线程不会看到中间状态。Interlocked.CompareExchange 可以做「比较并交换」,是实现无锁算法的基础。
但 Interlocked 只保证单个操作原子。如果你需要「读取、判断、再修改」这一整段逻辑原子,单靠 Interlocked 不够,还是得用锁或专门的并发结构。比如「如果不存在就插入,存在就更新」,应该用 ConcurrentDictionary.AddOrUpdate,而不是先 TryGetValue 再赋值。
ConcurrentDictionary 的常用方法是 AddOrUpdate、GetOrAdd、TryUpdate、TryRemove。它们把「查和改」合并成一个原子操作,适合多线程共享的缓存和计数器。要注意传给它的委托可能被执行多次,所以委托里不要做有副作用的事,比如写日志、发消息、修改外部状态。
ConcurrentQueue、ConcurrentStack、ConcurrentBag 分别对应队列、栈和无序包,适合生产者消费者场景。它们保证单个操作线程安全,但「先判断再操作」的组合仍然需要额外同步。并发集合不是万能药,它只把常见操作变安全,不会自动保证业务逻辑的原子性。
Interlocked.CompareExchange 的典型用法是「如果还是旧值,就换成新值」:
int expected = 10;
int updated = 11;
int actual = Interlocked.CompareExchange(ref value, updated, expected);
// actual 等于 expected 表示替换成功;否则说明别的线程已经改过
它把比较和替换合成一个原子步骤,是实现无锁计数器和状态标志的基础。但无锁代码很难写对,条件稍微复杂一点就容易出现 ABA 问题或活锁。业务代码优先用锁和现成的并发集合,把无锁留给确实需要极致性能、并且能充分测试的场景。
死锁:两把锁,两个方向
死锁最经典的形态是:线程 A 先拿锁 1 再拿锁 2,线程 B 先拿锁 2 再拿锁 1。两个人各拿到第一把,又都在等对方手里的第二把,谁也不放手。上面的例子用 Monitor.TryEnter 加超时,在等不到时放弃并打印提示,避免了真的卡死。
避免死锁的办法有几个。第一,全局约定锁的获取顺序,所有代码都按同一个顺序拿锁。第二,尽量不要在持有一把锁的时候去拿另一把,能把锁的范围缩小就缩小。第三,必须嵌套时用 Monitor.TryEnter 带超时,等不到就回退,不要让线程无限等待。第四,考虑用无锁结构或消息传递,减少共享锁的需求。
if (!Monitor.TryEnter(lockA, TimeSpan.FromMilliseconds(300)))
{
// 拿不到就放弃,做降级处理
return;
}
try
{
// 持有 lockA 的工作
}
finally
{
Monitor.Exit(lockA);
}
注意 Monitor.Exit 必须放在 finally 里,否则中途抛异常会导致锁永远不释放。lock 语法糖已经帮你做了这件事,手写 Monitor 时不要漏。同理,任何「获取资源后必须释放」的场景,都要用 try/finally 或 using 包住。
线上出现疑似死锁时,先抓线程堆栈,不要急着重启。堆栈里能看到每个线程当前停在哪个方法、持有哪些锁、在等哪个锁。有了这些信息,才能判断是锁顺序问题、锁没释放,还是线程池饥饿造成的假死。重启只能暂时恢复,根因还在。
线程池饥饿:阻塞会把池子吃光
线程池的线程数量不是无限的。默认情况下,它会根据 CPU 核数和负载逐步增加,但增加速度有限。如果大量任务在池子里执行阻塞操作,比如同步等 I/O、Thread.Sleep、.Result,这些线程就被占着不干活,新任务只能排队。这就是线程池饥饿。
饥饿的表现是「没有死锁,也没有报错,但所有异步操作都变慢」。日志里看不到异常,CPU 也不高,请求就是迟迟不返回。排查时可以看线程池的线程数、队列长度,以及代码里有多少同步阻塞调用。
解决办法是让 I/O 走真正的异步,不要用 Task.Run 包住同步阻塞。数据库、HTTP、文件读写都提供了异步 API,用 await 等待时线程会被释放回池子,能服务其他任务。计算密集的短任务才适合 Task.Run,而且数量要受控。
线程池增加线程的策略比较保守,短时间内大量阻塞不会立刻补充线程,而是逐步增加。所以饥饿往往表现为「刚开始还行,负载一高就全面变慢」,等线程补上来又恢复,过一阵再次变慢。这种锯齿状的表现,靠加机器不一定能解决,得从代码里去掉阻塞调用。
ThreadPool.SetMaxThreads(4, 4) 人为限制线程池复现饥饿,但在本机 .NET 8 上该设置没有把上限压到 4,输出仍是 32767,队列任务只等了 2 毫秒。因此这里只讲机制,不贴编造的数字。真实项目中可以用压力测试和线程池监控来观察。真实项目里的现象与排查方向
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 多线程计数结果比预期少 | counter++ 不是原子操作,读改写被交错 | 检查共享字段的更新是否加锁或用 Interlocked |
| 集合偶发抛索引越界或数据错乱 | List 和 Dictionary 不是线程安全的 | 确认所有读写路径是否用同一把锁或并发集合 |
| 程序卡住,CPU 不高,也不报错 | 死锁,两个线程互相等对方持有的锁 | 抓线程堆栈,看每个线程持有哪些锁、在等哪些锁 |
| 异步请求越来越慢,线程数上涨 | 线程池饥饿,池子线程被同步阻塞占满 | 搜 .Result、.Wait()、Thread.Sleep 和同步 I/O |
| 加锁后性能反而下降很多 | 锁粒度过大,所有线程串行执行 | 看锁保护的代码范围,是否能拆小或改用并发结构 |
| ConcurrentDictionary 更新后计数不对 | AddOrUpdate 的委托被执行多次,委托里有副作用 | 检查委托是否只做纯计算,不要写外部状态 |
| 锁字符串或 lock(this) 后出现奇怪阻塞 | 锁对象被外部共享,不同代码路径争同一把锁 | 改成私有专用锁对象,不要锁公开可见的引用 |
| 程序退出时还有后台线程在跑 | 创建了前台线程,或任务没有被等待和取消 | 检查 Thread.IsBackground 和任务的等待、取消逻辑 |
排查并发问题的核心是拿到「谁持有锁、谁在等锁、谁在占线程」。只看代码很难判断,必须结合线程堆栈和运行时指标。不要靠加日志打印来猜,日志本身也可能被并发打乱。
边界与代价
- 多线程不一定更快:线程创建、调度、上下文切换都有成本。任务太短或共享状态太多时,并行可能比串行还慢。
- 锁会串行化访问:锁保护的范围越大,并发度越低。共享状态越少,扩展性越好,设计时优先考虑「不共享」而不是「加锁共享」。
- 原子操作只保证单步:Interlocked 解决不了复合逻辑的竞态。需要多个字段一起变化时,还是要有锁或事务性结构。
- 并发集合不保证业务原子性:单个方法线程安全,组合操作仍可能被其他线程插入。业务不变量要靠锁或专门设计来保护。
- 死锁可能跨组件:你只知道自己拿了什么锁,不知道调用的第三方方法内部拿了什么锁。调用外部代码时尽量避免持有锁。
- 线程池容量有限:阻塞调用会占住线程,异步等待才能释放。不要把线程池当成可以无限扩张的资源。
还有一个原则:能用不可变数据就不共享可变状态,能在线程内部完成就不跨线程传递。并发问题最彻底的解决办法是减少共享,而不是把锁写得越来越复杂。
当天能自己验证的练习
以下练习都在一个控制台项目里完成,改 Program.cs 后执行 dotnet run:
- 去掉本文例子里的 lock,让 8 个任务各加一万次,多跑几遍,记录每次的结果,确认它不是稳定等于 80000。
- 把 lock 换成
Interlocked.Increment,对比结果和耗时,确认两种写法都能得到正确值。 - 用普通 Dictionary 代替 ConcurrentDictionary,在 Parallel.For 里更新,观察是否抛异常或丢数据;再换回并发字典对比。
- 写两个任务,按相反顺序获取两把锁,用普通 lock 复现卡住;再用
Monitor.TryEnter加超时,确认程序能继续执行。 - 把一段同步文件读取放进 Task.Run,连续提交很多个,观察线程数和响应时间;再改成异步读取,对比行为差异。
小结
三句话收一下:共享可变状态是并发的根源,counter++ 不是原子操作,简单计数用 Interlocked,复合逻辑用锁或并发结构;锁对象要私有、粒度要合理,嵌套锁要统一顺序并加超时;线程池线程有限,阻塞调用会吃光池子,I/O 要用真正的异步。
多线程解决的是「同时执行」,异步解决的是「等待时不占线程」。下一篇讲 async 和 await:编译器到底生成了什么、为什么 async 方法要一路 async 到底、CancellationToken 怎么传、Task.WhenAll 和 Parallel.For 各适合什么场景。