lock关键字用于基本线程互斥，Monitor提供更灵活的锁控制；2. Mutex支持跨进程同步但性能较低；3. SemaphoreSlim限制并发访问数，适合异步场景；4. ReaderWriterLockSlim优化读多写少场景；5. Interlocked实现原子操作提升性能；6. volatile确保变量可见性。根据需求选择合适机制可有效避免数据竞争与不一致问题。

在 .NET 多线程编程中，线程同步是防止多个线程同时访问共享资源导致数据不一致的关键手段。.NET 提供了多种机制来实现线程同步，每种适用于不同的场景。以下是几种常用的线程同步方式及其使用方法。

1. lock 关键字（Monitor 类）

lock 是最常用、最简单的线程同步方式，本质上是对 Monitor 类的封装，确保同一时间只有一个线程可以进入临界区。

private static readonly object lockObj = new object();
private static int counter = 0;

public static void Increment()
{
    lock (lockObj)
    {
        counter++;
    }
}

注意：lock 的对象应为私有、静态、只读的 object 实例，避免使用 public 或 this，以防外部锁定造成死锁。

2. Monitor 类（更灵活的锁控制）

Monitor 提供比 lock 更细粒度的控制，比如可以设置超时、手动释放等。

if (Monitor.TryEnter(lockObj, 1000)) // 等待最多1秒
{
    try
    {
        counter++;
    }
    finally
    {
        Monitor.Exit(lockObj);
    }
}
else
{
    // 获取锁失败
}

Monitor 适合需要处理超时或异常退出的复杂场景。

3. Mutex（跨进程同步）

Mutex 是一个重量级同步原语，支持跨进程的线程同步，常用于限制应用只能运行一个实例。

using (var mutex = new Mutex(false, "MyAppUniqueName"))
{
    if (mutex.WaitOne(0))
    {
        // 成功获取互斥锁，启动主程序
        Console.WriteLine("程序启动");
        Console.ReadLine();
    }
    else
    {
        Console.WriteLine("程序已在运行");
    }
}

Mutex 性能较低，仅在需要跨进程同步时使用。

4. Semaphore 和 SemaphoreSlim

信号量用于限制同时访问某一资源的线程数量。SemaphoreSlim 是轻量级、适合线程内异步操作的版本。

private static SemaphoreSlim semaphore = new SemaphoreSlim(3, 3); // 最多3个线程

public static async Task AccessResourceAsync()
{
    await semaphore.WaitAsync();
    try
    {
        Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 进入");
        await Task.Delay(1000);
    }
    finally
    {
        semaphore.Release();
    }
}

适合控制并发访问数据库连接池或API调用频率。

5. ReaderWriterLockSlim（读写锁）

当资源被频繁读取但很少写入时，使用 ReaderWriterLockSlim 可以提高性能，允许多个读线程同时访问，写线程独占。

private static ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
private static string sharedData = "初始值";

public static string ReadData()
{
    rwLock.EnterReadLock();
    try
    {
        return sharedData;
    }
    finally
    {
        rwLock.ExitReadLock();
    }
}

public static void WriteData(string value)
{
    rwLock.EnterWriteLock();
    try
    {
        sharedData = value;
    }
    finally
    {
        rwLock.ExitWriteLock();
    }
}

读多写少的场景下性能优于 lock。

6. Interlocked 类（原子操作）

对于简单的变量操作（如递增、交换），Interlocked 提供无锁的原子操作，效率高。

private static int counter = 0;

public static void Increment()
{
    Interlocked.Increment(ref counter);
}

适用于计数器、状态标志等简单类型的操作。

7. volatile 关键字

volatile 用于确保字段的读写直接从主内存进行，不被线程本地缓存，适用于标志位。

private static volatile bool isRunning = true;

不能替代锁，但可配合其他同步机制使用，确保可见性。

基本上就这些常见的线程同步方式。选择哪种取决于你的具体需求：简单互斥用 lock，高性能原子操作用 Interlocked，读多写少用 ReaderWriterLockSlim，限制并发数用 SemaphoreSlim，跨进程用 Mutex。合理使用这些机制，可以有效避免竞态条件和数据损坏问题。