c# 线程同步的几种方式

来源：这里教程网时间：2026-02-21 17:37:36 作者：

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

绝大多数 C# 开发者第一反应就是

lock

，它底层基于

Monitor.Enter

Monitor.Exit

，用起来简单但有几个关键点必须注意：

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

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

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

当无法确定锁何时能释放（比如依赖外部服务响应），硬等

lock

会导致线程挂起甚至拖垮系统。

Monitor.TryEnter

提供带超时和可取消的入口控制：

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

private readonly object _syncLock = new object();
<p>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<string, string> _cache = new Dictionary<string, string>();
<p>public string Get(string key)
{
_rwLock.EnterReadLock();
try
{
return _cache.TryGetValue(key, out var value) ? value : null;
}
finally
{
_rwLock.ExitReadLock(); // ✅ 必须显式释放
}
}</p><p>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
<p>public void RecordRequest() => Interlocked.Increment(ref _requestCount);</p><p>public bool TryStart()
{
return Interlocked.CompareExchange(ref _status, 1, 0) == 0; // 仅当原值为 0 时设为 1
}

实际项目里，