c# 线程同步的几种方式_技术教程

lock最常用但易错，需注意锁对象生命周期、避免死锁和粒度控制；Monitor.TryEnter支持超时；ReaderWriterLockSlim适合读多写少；Interlocked适用于简单原子操作。

lock 语句是最常用也最容易出错的同步方式

绝大多数 C# 开发者第一反应就是 lock，它底层基于 Monitor.Enter / Monitor.Exit，用起来简单但有几个关键点必须注意：

lock 的对象必须是引用类型，且生命周期要稳定——不能是 new object() 放在方法内（每次新建不同实例，锁失效），更不能是值类型（会装箱成不同对象）
避免锁住 this、typeof(XXX) 或公共静态对象，容易引发外部死锁或意外争用
锁内不要调用可能阻塞或重入的代码（比如再调用另一个也用 lock 的方法），否则极易死锁
锁的粒度要尽量小：只包裹真正需要保护的共享资源读写段，而不是整个方法体

private readonly object _syncLock = new object();
private int _counter = 0;
public void Increment()
{
lock (_syncLock) // ✅ 正确：私有、只读、引用类型字段
{
_counter++; // 只包临界区
}
}

Monitor.TryEnter 可控超时，适合避免无限等待

当无法确定锁何时能释放（比如依赖外部服务响应），硬等 lock 会导致线程挂起甚至拖垮系统。Monitor.TryEnter 提供带超时和可取消的入口控制：

返回 bool 表示是否成功获取锁，不阻塞线程
支持毫秒整数超时，也支持 TimeSpan 和 CancellationToken
必须配对调用 Monitor.Exit（即使没拿到锁也要确保不漏释放）
比 lock 多一层手动管理，但更灵活

private readonly object _syncLock = new object();
public bool TryProcessWithTimeout(int timeoutMs = 100)
{
if (Monitor.TryEnter(_syncLock, timeoutMs))
{
try
{
// 执行临界区操作
return true;
}
finally
{
Monitor.Exit(_syncLock); // ✅ 必须保证释放
}
}
return false; // 超时未获取到锁
}

ReaderWriterLockSlim 适合读多写少的共享数据结构

如果某个对象被频繁读取、极少修改（比如配置缓存、路由表），用 lock 会让所有读操作排队，严重降低吞吐。ReaderWriterLockSlim 允许多个读线程并发，仅写时独占：

EnterReadLock / ExitReadLock：允许多个线程同时进入
EnterWriteLock / ExitWriteLock：写时阻塞所有读和写
支持升级策略（EnterUpgradeableReadLock），在读锁内判断需写时再升级，减少锁竞争
注意：它不支持递归获取（同一线程重复 Enter 会死锁），也不像 lock 那样自动释放

private readonly ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();
private Dictionary _cache = new Dictionary();
public string Get(string key)
{
_rwLock.EnterReadLock();
try
{
return _cache.TryGetValue(key, out var value) ? value : null;
}
finally
{
_rwLock.ExitReadLock(); // ✅ 必须显式释放
}
}
public void Set(string key, string value)
{
_rwLock.EnterWriteLock();
try
{
_cache[key] = value;
}
finally
{
_rwLock.ExitWriteLock();
}
}

Interlocked 类适用于简单原子操作，零开销

当只需要对整数、引用或指针做「读-改-写」原子操作（如计数器、标志位、无锁栈头更新），Interlocked 是最优选——它直接编译为 CPU 原子指令，没有锁开销，也不涉及线程调度：

Interlocked.Increment、Interlocked.CompareExchange、Interlocked.Exchange 最常用
只能用于 int、long、IntPtr、引用类型等有限类型
不能替代复杂逻辑同步（比如“如果余额 > 100 就扣款”，这需要 CompareExchange 循环重试，但业务逻辑一复杂就难维护）
注意：它不提供内存屏障之外的同步语义，对非原子字段组合操作无效

private long _requestCount = 0;
private int _status = 0; // 0=stopped, 1=running
public void RecordRequest() => Interlocked.Increment(ref _requestCount);
public bool TryStart()
{
return Interlocked.CompareExchange(ref _status, 1, 0) == 0; // 仅当原值为 0 时设为 1
}

实际项目里，lock 覆盖 80% 场景；但一旦出现性能瓶颈或死锁，得立刻想到 Monitor.TryEnter 控制等待、ReaderWriterLockSlim 分离读写、或者用 Interlocked 拆解原子动作——这些不是“高级技巧”，而是线程安全落地时绕不开的权衡点。