锁（Lock）：
使用lock关键字可以确保在同一时刻只有一个线程可以访问被锁定的代码块。
private static readonly object _lock = new object();
public void ThreadSafeMethod()
{
lock (_lock)
{
// 临界区代码
}
}
Monitor类：
Monitor类提供了更细粒度的控制，可以用于实现等待和通知机制。
private static readonly object _lock = new object();
private static bool _condition = false;
public void ThreadSafeMethod()
{
lock (_lock)
{
while (!_condition)
{
Monitor.Wait(_lock);
}
// 条件满足时执行的代码
}
}
public void SignalMethod()
{
lock (_lock)
{
_condition = true;
Monitor.Pulse(_lock);
}
}
WaitHandle类及其子类：
AutoResetEvent、ManualResetEvent、CountdownEvent等类用于线程间的同步。
private ManualResetEvent _resetEvent = new ManualResetEvent(false);
public void ThreadMethod()
{
_resetEvent.WaitOne();
// 线程被唤醒后执行的代码
}
public void SignalMethod()
{
_resetEvent.Set(); // 唤醒一个正在等待的线程
}
Interlocked类：
Interlocked类提供了原子操作，确保对共享变量的读写操作是线程安全的。
private static int _counter = 0;
public void IncrementCounter()
{
Interlocked.Increment(ref _counter);
}
Volatile关键字：
volatile关键字用于指示某个字段不应该被编译器优化，以确保线程能够看到最新的值。
private static volatile bool _flag = false;
public void SetFlag()
{
_flag = true;
}
public void CheckFlag()
{
if (_flag)
{
// 执行相关操作
}
}
使用线程安全的集合类：
.NET提供了多种线程安全的集合类，如ConcurrentDictionary、ConcurrentQueue、ConcurrentStack等。
private ConcurrentDictionary
public void AddToDictionary(int key, string value)
{
_concurrentDictionary.TryAdd(key, value);
}
public string GetFromDictionary(int key)
{
if (_concurrentDictionary.TryGetValue(key, out string value))
{
return value;
}
return null;
}
使用Mutex和Semaphore：
Mutex用于确保同一时间只有一个线程可以访问共享资源。
Semaphore用于限制同时访问共享资源的线程数量。
private static Mutex _mutex = new Mutex();
public void ThreadSafeMethod()
{
_mutex.WaitOne();
try
{
// 临界区代码
}
finally
{
_mutex.ReleaseMutex();
}
}
private static Semaphore _semaphore = new Semaphore(2, 2); // 允许最多2个线程
public void ThreadSafeMethod()
{
_semaphore.WaitOne();
try
{
// 临界区代码
}
finally
{
_semaphore.Release();
}
}
使用Task和async/await：
使用Task和异步编程模型（async/await）可以更好地管理并发操作，减少线程阻塞。
public async Task ThreadSafeMethodAsync()
{
await Task.Run(() =>
{
// 异步任务代码
});
}